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

3352 {
3353  while (true)
3354  {
3356  {
3357  /*
3358  * If we failed while trying to create a subtransaction, clean
3359  * up the broken subtransaction and abort the parent. The
3360  * same applies if we get a failure while ending a
3361  * subtransaction.
3362  */
3363  case TBLOCK_SUBBEGIN:
3364  case TBLOCK_SUBRELEASE:
3365  case TBLOCK_SUBCOMMIT:
3367  case TBLOCK_SUBRESTART:
3370  continue;
3371 
3372  /*
3373  * Same as above, except the Abort() was already done.
3374  */
3375  case TBLOCK_SUBABORT_END:
3378  continue;
3379  default:
3380  break;
3381  }
3383  break;
3384  }
3385 }
TBlockState blockState
Definition: xact.c:194
static void AbortCurrentTransactionInternal(void)
Definition: xact.c:3393
static void CleanupSubTransaction(void)
Definition: xact.c:5306
static void AbortSubTransaction(void)
Definition: xact.c:5134
@ TBLOCK_SUBABORT_END
Definition: xact.c:178
@ TBLOCK_SUBCOMMIT
Definition: xact.c:176
@ TBLOCK_SUBRELEASE
Definition: xact.c:175
@ TBLOCK_SUBBEGIN
Definition: xact.c:173
@ TBLOCK_SUBRESTART
Definition: xact.c:180
@ TBLOCK_SUBABORT_RESTART
Definition: xact.c:181
@ TBLOCK_SUBABORT_PENDING
Definition: xact.c:179
static TransactionState CurrentTransactionState
Definition: xact.c:252

References AbortCurrentTransactionInternal(), AbortSubTransaction(), TransactionStateData::blockState, CleanupSubTransaction(), CurrentTransactionState, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBABORT_RESTART, TBLOCK_SUBBEGIN, TBLOCK_SUBCOMMIT, TBLOCK_SUBRELEASE, and TBLOCK_SUBRESTART.

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

◆ AbortOutOfAnyTransaction()

void AbortOutOfAnyTransaction ( void  )

Definition at line 4788 of file xact.c.

4789 {
4791 
4792  /* Ensure we're not running in a doomed memory context */
4793  AtAbort_Memory();
4794 
4795  /*
4796  * Get out of any transaction or nested transaction
4797  */
4798  do
4799  {
4800  switch (s->blockState)
4801  {
4802  case TBLOCK_DEFAULT:
4803  if (s->state == TRANS_DEFAULT)
4804  {
4805  /* Not in a transaction, do nothing */
4806  }
4807  else
4808  {
4809  /*
4810  * We can get here after an error during transaction start
4811  * (state will be TRANS_START). Need to clean up the
4812  * incompletely started transaction. First, adjust the
4813  * low-level state to suppress warning message from
4814  * AbortTransaction.
4815  */
4816  if (s->state == TRANS_START)
4817  s->state = TRANS_INPROGRESS;
4818  AbortTransaction();
4820  }
4821  break;
4822  case TBLOCK_STARTED:
4823  case TBLOCK_BEGIN:
4824  case TBLOCK_INPROGRESS:
4827  case TBLOCK_END:
4828  case TBLOCK_ABORT_PENDING:
4829  case TBLOCK_PREPARE:
4830  /* In a transaction, so clean up */
4831  AbortTransaction();
4834  break;
4835  case TBLOCK_ABORT:
4836  case TBLOCK_ABORT_END:
4837 
4838  /*
4839  * AbortTransaction is already done, still need Cleanup.
4840  * However, if we failed partway through running ROLLBACK,
4841  * there will be an active portal running that command, which
4842  * we need to shut down before doing CleanupTransaction.
4843  */
4844  AtAbort_Portals();
4847  break;
4848 
4849  /*
4850  * In a subtransaction, so clean it up and abort parent too
4851  */
4852  case TBLOCK_SUBBEGIN:
4853  case TBLOCK_SUBINPROGRESS:
4854  case TBLOCK_SUBRELEASE:
4855  case TBLOCK_SUBCOMMIT:
4857  case TBLOCK_SUBRESTART:
4860  s = CurrentTransactionState; /* changed by pop */
4861  break;
4862 
4863  case TBLOCK_SUBABORT:
4864  case TBLOCK_SUBABORT_END:
4866  /* As above, but AbortSubTransaction already done */
4867  if (s->curTransactionOwner)
4868  {
4869  /* As in TBLOCK_ABORT, might have a live portal to zap */
4874  }
4876  s = CurrentTransactionState; /* changed by pop */
4877  break;
4878  }
4879  } while (s->blockState != TBLOCK_DEFAULT);
4880 
4881  /* Should be out of all subxacts now */
4882  Assert(s->parent == NULL);
4883 
4884  /* If we didn't actually have anything to do, revert to TopMemoryContext */
4885  AtCleanup_Memory();
4886 }
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
TransState state
Definition: xact.c:193
SubTransactionId subTransactionId
Definition: xact.c:190
struct TransactionStateData * parent
Definition: xact.c:210
ResourceOwner curTransactionOwner
Definition: xact.c:198
static void CleanupTransaction(void)
Definition: xact.c:2906
@ TRANS_INPROGRESS
Definition: xact.c:143
@ TRANS_START
Definition: xact.c:142
@ TRANS_DEFAULT
Definition: xact.c:141
static void AtCleanup_Memory(void)
Definition: xact.c:1923
static void AtAbort_Memory(void)
Definition: xact.c:1833
@ TBLOCK_DEFAULT
Definition: xact.c:158
@ TBLOCK_STARTED
Definition: xact.c:159
@ 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_SUBABORT
Definition: xact.c:177
@ TBLOCK_INPROGRESS
Definition: xact.c:163
@ TBLOCK_END
Definition: xact.c:166
@ TBLOCK_PARALLEL_INPROGRESS
Definition: xact.c:165
@ TBLOCK_BEGIN
Definition: xact.c:162
@ TBLOCK_SUBINPROGRESS
Definition: xact.c:174
static void AbortTransaction(void)
Definition: xact.c:2711

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

4249 {
4251 
4252  /*
4253  * If we are in STARTED state (that is, no transaction block is open),
4254  * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4255  * block.
4256  *
4257  * For caller convenience, we consider all other transaction states as
4258  * legal here; otherwise the caller would need its own state check, which
4259  * seems rather pointless.
4260  */
4261  if (s->blockState == TBLOCK_STARTED)
4263 }

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

Referenced by exec_simple_query().

◆ BeginInternalSubTransaction()

void BeginInternalSubTransaction ( const char *  name)

Definition at line 4616 of file xact.c.

4617 {
4619 
4620  /*
4621  * Workers synchronize transaction state at the beginning of each parallel
4622  * operation, so we can't account for new subtransactions after that
4623  * point. We might be able to make an exception for the type of
4624  * subtransaction established by this function, which is typically used in
4625  * contexts where we're going to release or roll back the subtransaction
4626  * before proceeding further, so that no enduring change to the
4627  * transaction state occurs. For now, however, we prohibit this case along
4628  * with all the others.
4629  */
4630  if (IsInParallelMode())
4631  ereport(ERROR,
4632  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4633  errmsg("cannot start subtransactions during a parallel operation")));
4634 
4635  switch (s->blockState)
4636  {
4637  case TBLOCK_STARTED:
4638  case TBLOCK_INPROGRESS:
4640  case TBLOCK_END:
4641  case TBLOCK_PREPARE:
4642  case TBLOCK_SUBINPROGRESS:
4643  /* Normal subtransaction start */
4644  PushTransaction();
4645  s = CurrentTransactionState; /* changed by push */
4646 
4647  /*
4648  * Savepoint names, like the TransactionState block itself, live
4649  * in TopTransactionContext.
4650  */
4651  if (name)
4653  break;
4654 
4655  /* These cases are invalid. */
4656  case TBLOCK_DEFAULT:
4657  case TBLOCK_BEGIN:
4659  case TBLOCK_SUBBEGIN:
4660  case TBLOCK_SUBRELEASE:
4661  case TBLOCK_SUBCOMMIT:
4662  case TBLOCK_ABORT:
4663  case TBLOCK_SUBABORT:
4664  case TBLOCK_ABORT_END:
4665  case TBLOCK_SUBABORT_END:
4666  case TBLOCK_ABORT_PENDING:
4668  case TBLOCK_SUBRESTART:
4670  elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
4672  break;
4673  }
4674 
4677 }
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:1670
const char * name
static void PushTransaction(void)
Definition: xact.c:5339
void StartTransactionCommand(void)
Definition: xact.c:2955
bool IsInParallelMode(void)
Definition: xact.c:1070
static const char * BlockStateAsString(TBlockState blockState)
Definition: xact.c:5629
void CommitTransactionCommand(void)
Definition: xact.c:3053

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

3847 {
3849 
3850  switch (s->blockState)
3851  {
3852  /*
3853  * We are not inside a transaction block, so allow one to begin.
3854  */
3855  case TBLOCK_STARTED:
3856  s->blockState = TBLOCK_BEGIN;
3857  break;
3858 
3859  /*
3860  * BEGIN converts an implicit transaction block to a regular one.
3861  * (Note that we allow this even if we've already done some
3862  * commands, which is a bit odd but matches historical practice.)
3863  */
3865  s->blockState = TBLOCK_BEGIN;
3866  break;
3867 
3868  /*
3869  * Already a transaction block in progress.
3870  */
3871  case TBLOCK_INPROGRESS:
3873  case TBLOCK_SUBINPROGRESS:
3874  case TBLOCK_ABORT:
3875  case TBLOCK_SUBABORT:
3876  ereport(WARNING,
3877  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3878  errmsg("there is already a transaction in progress")));
3879  break;
3880 
3881  /* These cases are invalid. */
3882  case TBLOCK_DEFAULT:
3883  case TBLOCK_BEGIN:
3884  case TBLOCK_SUBBEGIN:
3885  case TBLOCK_END:
3886  case TBLOCK_SUBRELEASE:
3887  case TBLOCK_SUBCOMMIT:
3888  case TBLOCK_ABORT_END:
3889  case TBLOCK_SUBABORT_END:
3890  case TBLOCK_ABORT_PENDING:
3892  case TBLOCK_SUBRESTART:
3894  case TBLOCK_PREPARE:
3895  elog(FATAL, "BeginTransactionBlock: unexpected state %s",
3897  break;
3898  }
3899 }
#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 1079 of file xact.c.

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

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(), CommitTransactionCommandInternal(), 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 3053 of file xact.c.

3054 {
3055  while (true)
3056  {
3058  {
3059  /*
3060  * The current already-failed subtransaction is ending due to
3061  * a ROLLBACK or ROLLBACK TO command, so pop it and
3062  * recursively examine the parent (which could be in any of
3063  * several states).
3064  */
3065  case TBLOCK_SUBABORT_END:
3067  continue;
3068 
3069  /*
3070  * As above, but it's not dead yet, so abort first.
3071  */
3075  continue;
3076  default:
3077  break;
3078  }
3080  break;
3081  }
3082 }
static void CommitTransactionCommandInternal(void)
Definition: xact.c:3090

References AbortSubTransaction(), TransactionStateData::blockState, CleanupSubTransaction(), CommitTransactionCommandInternal(), CurrentTransactionState, TBLOCK_SUBABORT_END, and TBLOCK_SUBABORT_PENDING.

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

4296 {
4298 
4299  /*
4300  * Workers synchronize transaction state at the beginning of each parallel
4301  * operation, so we can't account for new subtransactions after that
4302  * point. (Note that this check will certainly error out if s->blockState
4303  * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4304  * below.)
4305  */
4306  if (IsInParallelMode())
4307  ereport(ERROR,
4308  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4309  errmsg("cannot define savepoints during a parallel operation")));
4310 
4311  switch (s->blockState)
4312  {
4313  case TBLOCK_INPROGRESS:
4314  case TBLOCK_SUBINPROGRESS:
4315  /* Normal subtransaction start */
4316  PushTransaction();
4317  s = CurrentTransactionState; /* changed by push */
4318 
4319  /*
4320  * Savepoint names, like the TransactionState block itself, live
4321  * in TopTransactionContext.
4322  */
4323  if (name)
4325  break;
4326 
4327  /*
4328  * We disallow savepoint commands in implicit transaction blocks.
4329  * There would be no great difficulty in allowing them so far as
4330  * this module is concerned, but a savepoint seems inconsistent
4331  * with exec_simple_query's behavior of abandoning the whole query
4332  * string upon error. Also, the point of an implicit transaction
4333  * block (as opposed to a regular one) is to automatically close
4334  * after an error, so it's hard to see how a savepoint would fit
4335  * into that.
4336  *
4337  * The error messages for this are phrased as if there were no
4338  * active transaction block at all, which is historical but
4339  * perhaps could be improved.
4340  */
4342  ereport(ERROR,
4343  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4344  /* translator: %s represents an SQL statement name */
4345  errmsg("%s can only be used in transaction blocks",
4346  "SAVEPOINT")));
4347  break;
4348 
4349  /* These cases are invalid. */
4350  case TBLOCK_DEFAULT:
4351  case TBLOCK_STARTED:
4352  case TBLOCK_BEGIN:
4354  case TBLOCK_SUBBEGIN:
4355  case TBLOCK_END:
4356  case TBLOCK_SUBRELEASE:
4357  case TBLOCK_SUBCOMMIT:
4358  case TBLOCK_ABORT:
4359  case TBLOCK_SUBABORT:
4360  case TBLOCK_ABORT_END:
4361  case TBLOCK_SUBABORT_END:
4362  case TBLOCK_ABORT_PENDING:
4364  case TBLOCK_SUBRESTART:
4366  case TBLOCK_PREPARE:
4367  elog(FATAL, "DefineSavepoint: unexpected state %s",
4369  break;
4370  }
4371 }

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 CommitTransactionCommandInternal(), pa_start_subtrans(), and standard_ProcessUtility().

◆ EndImplicitTransactionBlock()

void EndImplicitTransactionBlock ( void  )

Definition at line 4273 of file xact.c.

4274 {
4276 
4277  /*
4278  * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4279  * allowing CommitTransactionCommand to commit whatever happened during
4280  * the implicit transaction block as though it were a single statement.
4281  *
4282  * For caller convenience, we consider all other transaction states as
4283  * legal here; otherwise the caller would need its own state check, which
4284  * seems rather pointless.
4285  */
4288 }

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

Referenced by exec_simple_query().

◆ EndParallelWorkerTransaction()

void EndParallelWorkerTransaction ( void  )

◆ EndTransactionBlock()

bool EndTransactionBlock ( bool  chain)

Definition at line 3966 of file xact.c.

3967 {
3969  bool result = false;
3970 
3971  switch (s->blockState)
3972  {
3973  /*
3974  * We are in a transaction block, so tell CommitTransactionCommand
3975  * to COMMIT.
3976  */
3977  case TBLOCK_INPROGRESS:
3978  s->blockState = TBLOCK_END;
3979  result = true;
3980  break;
3981 
3982  /*
3983  * We are in an implicit transaction block. If AND CHAIN was
3984  * specified, error. Otherwise commit, but issue a warning
3985  * because there was no explicit BEGIN before this.
3986  */
3988  if (chain)
3989  ereport(ERROR,
3990  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
3991  /* translator: %s represents an SQL statement name */
3992  errmsg("%s can only be used in transaction blocks",
3993  "COMMIT AND CHAIN")));
3994  else
3995  ereport(WARNING,
3996  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
3997  errmsg("there is no transaction in progress")));
3998  s->blockState = TBLOCK_END;
3999  result = true;
4000  break;
4001 
4002  /*
4003  * We are in a failed transaction block. Tell
4004  * CommitTransactionCommand it's time to exit the block.
4005  */
4006  case TBLOCK_ABORT:
4008  break;
4009 
4010  /*
4011  * We are in a live subtransaction block. Set up to subcommit all
4012  * open subtransactions and then commit the main transaction.
4013  */
4014  case TBLOCK_SUBINPROGRESS:
4015  while (s->parent != NULL)
4016  {
4017  if (s->blockState == TBLOCK_SUBINPROGRESS)
4019  else
4020  elog(FATAL, "EndTransactionBlock: unexpected state %s",
4022  s = s->parent;
4023  }
4024  if (s->blockState == TBLOCK_INPROGRESS)
4025  s->blockState = TBLOCK_END;
4026  else
4027  elog(FATAL, "EndTransactionBlock: unexpected state %s",
4029  result = true;
4030  break;
4031 
4032  /*
4033  * Here we are inside an aborted subtransaction. Treat the COMMIT
4034  * as ROLLBACK: set up to abort everything and exit the main
4035  * transaction.
4036  */
4037  case TBLOCK_SUBABORT:
4038  while (s->parent != NULL)
4039  {
4040  if (s->blockState == TBLOCK_SUBINPROGRESS)
4042  else if (s->blockState == TBLOCK_SUBABORT)
4044  else
4045  elog(FATAL, "EndTransactionBlock: unexpected state %s",
4047  s = s->parent;
4048  }
4049  if (s->blockState == TBLOCK_INPROGRESS)
4051  else if (s->blockState == TBLOCK_ABORT)
4053  else
4054  elog(FATAL, "EndTransactionBlock: unexpected state %s",
4056  break;
4057 
4058  /*
4059  * The user issued COMMIT when not inside a transaction. For
4060  * COMMIT without CHAIN, issue a WARNING, staying in
4061  * TBLOCK_STARTED state. The upcoming call to
4062  * CommitTransactionCommand() will then close the transaction and
4063  * put us back into the default state. For COMMIT AND CHAIN,
4064  * error.
4065  */
4066  case TBLOCK_STARTED:
4067  if (chain)
4068  ereport(ERROR,
4069  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4070  /* translator: %s represents an SQL statement name */
4071  errmsg("%s can only be used in transaction blocks",
4072  "COMMIT AND CHAIN")));
4073  else
4074  ereport(WARNING,
4075  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4076  errmsg("there is no transaction in progress")));
4077  result = true;
4078  break;
4079 
4080  /*
4081  * The user issued a COMMIT that somehow ran inside a parallel
4082  * worker. We can't cope with that.
4083  */
4085  ereport(FATAL,
4086  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4087  errmsg("cannot commit during a parallel operation")));
4088  break;
4089 
4090  /* These cases are invalid. */
4091  case TBLOCK_DEFAULT:
4092  case TBLOCK_BEGIN:
4093  case TBLOCK_SUBBEGIN:
4094  case TBLOCK_END:
4095  case TBLOCK_SUBRELEASE:
4096  case TBLOCK_SUBCOMMIT:
4097  case TBLOCK_ABORT_END:
4098  case TBLOCK_SUBABORT_END:
4099  case TBLOCK_ABORT_PENDING:
4101  case TBLOCK_SUBRESTART:
4103  case TBLOCK_PREPARE:
4104  elog(FATAL, "EndTransactionBlock: unexpected state %s",
4106  break;
4107  }
4108 
4110  s->blockState == TBLOCK_END ||
4111  s->blockState == TBLOCK_ABORT_END ||
4113 
4114  s->chain = chain;
4115 
4116  return result;
4117 }

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

5435 {
5436  TransactionState s;
5437  Size nxids = 0;
5439 
5440  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5441  {
5443  nxids = add_size(nxids, 1);
5444  nxids = add_size(nxids, s->nChildXids);
5445  }
5446 
5447  return add_size(size, mul_size(sizeof(TransactionId), nxids));
5448 }
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 1129 of file xact.c.

1130 {
1131  forceSyncCommit = true;
1132 }
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 819 of file xact.c.

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

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

505 {
507 
510  return s->fullTransactionId;
511 }
static void AssignTransactionId(TransactionState s)
Definition: xact.c:627

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

◆ GetCurrentFullTransactionIdIfAny()

FullTransactionId GetCurrentFullTransactionIdIfAny ( void  )

Definition at line 522 of file xact.c.

523 {
525 }

References CurrentTransactionState, and TransactionStateData::fullTransactionId.

◆ GetCurrentStatementStartTimestamp()

TimestampTz GetCurrentStatementStartTimestamp ( void  )

Definition at line 865 of file xact.c.

866 {
867  return stmtStartTimestamp;
868 }
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 856 of file xact.c.

857 {
858  return xactStartTimestamp;
859 }
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 877 of file xact.c.

878 {
880 
881  /* should only be called after commit / abort processing */
882  Assert(s->state == TRANS_DEFAULT ||
883  s->state == TRANS_COMMIT ||
884  s->state == TRANS_ABORT ||
885  s->state == TRANS_PREPARE);
886 
887  if (xactStopTimestamp == 0)
889 
890  return xactStopTimestamp;
891 }
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 599 of file xact.c.

600 {
602  static TransactionId stablexid = InvalidTransactionId;
603 
604  if (lxid != MyProc->vxid.lxid)
605  {
606  lxid = MyProc->vxid.lxid;
607  stablexid = GetTopTransactionIdIfAny();
608  if (!TransactionIdIsValid(stablexid))
609  stablexid = ReadNextTransactionId();
610  }
611 
612  Assert(TransactionIdIsValid(stablexid));
613 
614  return stablexid;
615 }
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:433

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

Referenced by xid_age().

◆ GetTopFullTransactionId()

FullTransactionId GetTopFullTransactionId ( void  )

Definition at line 475 of file xact.c.

476 {
480 }
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 491 of file xact.c.

492 {
494 }

References XactTopFullTransactionId.

Referenced by pg_current_xact_id_if_assigned().

◆ GetTopTransactionId()

◆ GetTopTransactionIdIfAny()

◆ IsAbortedTransactionBlockState()

◆ IsInParallelMode()

◆ IsInTransactionBlock()

bool IsInTransactionBlock ( bool  isTopLevel)

Definition at line 3688 of file xact.c.

3689 {
3690  /*
3691  * Return true on same conditions that would make
3692  * PreventInTransactionBlock error out
3693  */
3694  if (IsTransactionBlock())
3695  return true;
3696 
3697  if (IsSubTransaction())
3698  return true;
3699 
3701  return true;
3702 
3703  if (!isTopLevel)
3704  return true;
3705 
3708  return true;
3709 
3710  return false;
3711 }
bool IsSubTransaction(void)
Definition: xact.c:4965
bool IsTransactionBlock(void)
Definition: xact.c:4892
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 551 of file xact.c.

552 {
553  /* check whether it is already logged */
555  return false;
556 
557  /* wal_level has to be logical */
558  if (!XLogLogicalInfoActive())
559  return false;
560 
561  /* we need to be in a transaction state */
562  if (!IsTransactionState())
563  return false;
564 
565  /* it has to be a subtransaction */
566  if (!IsSubTransaction())
567  return false;
568 
569  /* the subtransaction has to have a XID assigned */
571  return false;
572 
573  return true;
574 }
bool IsTransactionState(void)
Definition: xact.c:379
TransactionId GetCurrentTransactionIdIfAny(void)
Definition: xact.c:463
#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 379 of file xact.c.

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

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

584 {
586 
588 }
bool IsSubxactTopXidLogPending(void)
Definition: xact.c:551

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

3915 {
3916  TransactionState s;
3917  bool result;
3918 
3919  /* Set up to commit the current transaction */
3920  result = EndTransactionBlock(false);
3921 
3922  /* If successful, change outer tblock state to PREPARE */
3923  if (result)
3924  {
3926 
3927  while (s->parent != NULL)
3928  s = s->parent;
3929 
3930  if (s->blockState == TBLOCK_END)
3931  {
3932  /* Save GID where PrepareTransaction can find it again */
3934 
3936  }
3937  else
3938  {
3939  /*
3940  * ignore case where we are not in a transaction;
3941  * EndTransactionBlock already issued a warning.
3942  */
3945  /* Don't send back a PREPARE result tag... */
3946  result = false;
3947  }
3948  }
3949 
3950  return result;
3951 }
static char * prepareGID
Definition: xact.c:280
bool EndTransactionBlock(bool chain)
Definition: xact.c:3966

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

3558 {
3559  /*
3560  * xact block already started?
3561  */
3562  if (IsTransactionBlock())
3563  ereport(ERROR,
3564  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3565  /* translator: %s represents an SQL statement name */
3566  errmsg("%s cannot run inside a transaction block",
3567  stmtType)));
3568 
3569  /*
3570  * subtransaction?
3571  */
3572  if (IsSubTransaction())
3573  ereport(ERROR,
3574  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3575  /* translator: %s represents an SQL statement name */
3576  errmsg("%s cannot run inside a subtransaction",
3577  stmtType)));
3578 
3579  /*
3580  * inside a pipeline that has started an implicit transaction?
3581  */
3583  ereport(ERROR,
3584  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3585  /* translator: %s represents an SQL statement name */
3586  errmsg("%s cannot be executed within a pipeline",
3587  stmtType)));
3588 
3589  /*
3590  * inside a function call?
3591  */
3592  if (!isTopLevel)
3593  ereport(ERROR,
3594  (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3595  /* translator: %s represents an SQL statement name */
3596  errmsg("%s cannot be executed from a function", stmtType)));
3597 
3598  /* If we got past IsTransactionBlock test, should be in default state */
3601  elog(FATAL, "cannot prevent transaction chain");
3602 
3603  /* All okay. Set the flag to make sure the right thing happens later. */
3605 }
#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 3786 of file xact.c.

3787 {
3788  SubXactCallbackItem *item;
3789 
3790  item = (SubXactCallbackItem *)
3792  item->callback = callback;
3793  item->arg = arg;
3794  item->next = SubXact_callbacks;
3795  SubXact_callbacks = item;
3796 }
MemoryContext TopMemoryContext
Definition: mcxt.c:137
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1168
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 3726 of file xact.c.

3727 {
3728  XactCallbackItem *item;
3729 
3730  item = (XactCallbackItem *)
3732  item->callback = callback;
3733  item->arg = arg;
3734  item->next = Xact_callbacks;
3735  Xact_callbacks = item;
3736 }
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 4687 of file xact.c.

4688 {
4690 
4691  /*
4692  * Workers synchronize transaction state at the beginning of each parallel
4693  * operation, so we can't account for commit of subtransactions after that
4694  * point. This should not happen anyway. Code calling this would
4695  * typically have called BeginInternalSubTransaction() first, failing
4696  * there.
4697  */
4698  if (IsInParallelMode())
4699  ereport(ERROR,
4700  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4701  errmsg("cannot commit subtransactions during a parallel operation")));
4702 
4703  if (s->blockState != TBLOCK_SUBINPROGRESS)
4704  elog(ERROR, "ReleaseCurrentSubTransaction: unexpected state %s",
4706  Assert(s->state == TRANS_INPROGRESS);
4709  s = CurrentTransactionState; /* changed by pop */
4710  Assert(s->state == TRANS_INPROGRESS);
4711 }
MemoryContext CurTransactionContext
Definition: mcxt.c:143
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
static void CommitSubTransaction(void)
Definition: xact.c:5025

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

4381 {
4383  TransactionState target,
4384  xact;
4385 
4386  /*
4387  * Workers synchronize transaction state at the beginning of each parallel
4388  * operation, so we can't account for transaction state change after that
4389  * point. (Note that this check will certainly error out if s->blockState
4390  * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4391  * below.)
4392  */
4393  if (IsInParallelMode())
4394  ereport(ERROR,
4395  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4396  errmsg("cannot release savepoints during a parallel operation")));
4397 
4398  switch (s->blockState)
4399  {
4400  /*
4401  * We can't release a savepoint if there is no savepoint defined.
4402  */
4403  case TBLOCK_INPROGRESS:
4404  ereport(ERROR,
4405  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4406  errmsg("savepoint \"%s\" does not exist", name)));
4407  break;
4408 
4410  /* See comment about implicit transactions in DefineSavepoint */
4411  ereport(ERROR,
4412  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4413  /* translator: %s represents an SQL statement name */
4414  errmsg("%s can only be used in transaction blocks",
4415  "RELEASE SAVEPOINT")));
4416  break;
4417 
4418  /*
4419  * We are in a non-aborted subtransaction. This is the only valid
4420  * case.
4421  */
4422  case TBLOCK_SUBINPROGRESS:
4423  break;
4424 
4425  /* These cases are invalid. */
4426  case TBLOCK_DEFAULT:
4427  case TBLOCK_STARTED:
4428  case TBLOCK_BEGIN:
4430  case TBLOCK_SUBBEGIN:
4431  case TBLOCK_END:
4432  case TBLOCK_SUBRELEASE:
4433  case TBLOCK_SUBCOMMIT:
4434  case TBLOCK_ABORT:
4435  case TBLOCK_SUBABORT:
4436  case TBLOCK_ABORT_END:
4437  case TBLOCK_SUBABORT_END:
4438  case TBLOCK_ABORT_PENDING:
4440  case TBLOCK_SUBRESTART:
4442  case TBLOCK_PREPARE:
4443  elog(FATAL, "ReleaseSavepoint: unexpected state %s",
4445  break;
4446  }
4447 
4448  for (target = s; PointerIsValid(target); target = target->parent)
4449  {
4450  if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
4451  break;
4452  }
4453 
4454  if (!PointerIsValid(target))
4455  ereport(ERROR,
4456  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4457  errmsg("savepoint \"%s\" does not exist", name)));
4458 
4459  /* disallow crossing savepoint level boundaries */
4460  if (target->savepointLevel != s->savepointLevel)
4461  ereport(ERROR,
4462  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4463  errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
4464 
4465  /*
4466  * Mark "commit pending" all subtransactions up to the target
4467  * subtransaction. The actual commits will happen when control gets to
4468  * CommitTransactionCommand.
4469  */
4470  xact = CurrentTransactionState;
4471  for (;;)
4472  {
4474  xact->blockState = TBLOCK_SUBRELEASE;
4475  if (xact == target)
4476  break;
4477  xact = xact->parent;
4478  Assert(PointerIsValid(xact));
4479  }
4480 }
#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 3635 of file xact.c.

3636 {
3637  CheckTransactionBlock(isTopLevel, true, stmtType);
3638 }
static void CheckTransactionBlock(bool isTopLevel, bool throwError, const char *stmtType)
Definition: xact.c:3644

References CheckTransactionBlock().

Referenced by PerformCursorOpen(), and standard_ProcessUtility().

◆ RestoreTransactionCharacteristics()

◆ RollbackAndReleaseCurrentSubTransaction()

void RollbackAndReleaseCurrentSubTransaction ( void  )

Definition at line 4721 of file xact.c.

4722 {
4724 
4725  /*
4726  * Unlike ReleaseCurrentSubTransaction(), this is nominally permitted
4727  * during parallel operations. That's because we may be in the leader,
4728  * recovering from an error thrown while we were in parallel mode. We
4729  * won't reach here in a worker, because BeginInternalSubTransaction()
4730  * will have failed.
4731  */
4732 
4733  switch (s->blockState)
4734  {
4735  /* Must be in a subtransaction */
4736  case TBLOCK_SUBINPROGRESS:
4737  case TBLOCK_SUBABORT:
4738  break;
4739 
4740  /* These cases are invalid. */
4741  case TBLOCK_DEFAULT:
4742  case TBLOCK_STARTED:
4743  case TBLOCK_BEGIN:
4746  case TBLOCK_SUBBEGIN:
4747  case TBLOCK_INPROGRESS:
4748  case TBLOCK_END:
4749  case TBLOCK_SUBRELEASE:
4750  case TBLOCK_SUBCOMMIT:
4751  case TBLOCK_ABORT:
4752  case TBLOCK_ABORT_END:
4753  case TBLOCK_SUBABORT_END:
4754  case TBLOCK_ABORT_PENDING:
4756  case TBLOCK_SUBRESTART:
4758  case TBLOCK_PREPARE:
4759  elog(FATAL, "RollbackAndReleaseCurrentSubTransaction: unexpected state %s",
4761  break;
4762  }
4763 
4764  /*
4765  * Abort the current subtransaction, if needed.
4766  */
4767  if (s->blockState == TBLOCK_SUBINPROGRESS)
4769 
4770  /* And clean it up, too */
4772 
4773  s = CurrentTransactionState; /* changed by pop */
4775  s->blockState == TBLOCK_INPROGRESS ||
4777  s->blockState == TBLOCK_STARTED);
4778 }

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

4490 {
4492  TransactionState target,
4493  xact;
4494 
4495  /*
4496  * Workers synchronize transaction state at the beginning of each parallel
4497  * operation, so we can't account for transaction state change after that
4498  * point. (Note that this check will certainly error out if s->blockState
4499  * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4500  * below.)
4501  */
4502  if (IsInParallelMode())
4503  ereport(ERROR,
4504  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4505  errmsg("cannot rollback to savepoints during a parallel operation")));
4506 
4507  switch (s->blockState)
4508  {
4509  /*
4510  * We can't rollback to a savepoint if there is no savepoint
4511  * defined.
4512  */
4513  case TBLOCK_INPROGRESS:
4514  case TBLOCK_ABORT:
4515  ereport(ERROR,
4516  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4517  errmsg("savepoint \"%s\" does not exist", name)));
4518  break;
4519 
4521  /* See comment about implicit transactions in DefineSavepoint */
4522  ereport(ERROR,
4523  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4524  /* translator: %s represents an SQL statement name */
4525  errmsg("%s can only be used in transaction blocks",
4526  "ROLLBACK TO SAVEPOINT")));
4527  break;
4528 
4529  /*
4530  * There is at least one savepoint, so proceed.
4531  */
4532  case TBLOCK_SUBINPROGRESS:
4533  case TBLOCK_SUBABORT:
4534  break;
4535 
4536  /* These cases are invalid. */
4537  case TBLOCK_DEFAULT:
4538  case TBLOCK_STARTED:
4539  case TBLOCK_BEGIN:
4541  case TBLOCK_SUBBEGIN:
4542  case TBLOCK_END:
4543  case TBLOCK_SUBRELEASE:
4544  case TBLOCK_SUBCOMMIT:
4545  case TBLOCK_ABORT_END:
4546  case TBLOCK_SUBABORT_END:
4547  case TBLOCK_ABORT_PENDING:
4549  case TBLOCK_SUBRESTART:
4551  case TBLOCK_PREPARE:
4552  elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4554  break;
4555  }
4556 
4557  for (target = s; PointerIsValid(target); target = target->parent)
4558  {
4559  if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
4560  break;
4561  }
4562 
4563  if (!PointerIsValid(target))
4564  ereport(ERROR,
4565  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4566  errmsg("savepoint \"%s\" does not exist", name)));
4567 
4568  /* disallow crossing savepoint level boundaries */
4569  if (target->savepointLevel != s->savepointLevel)
4570  ereport(ERROR,
4571  (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4572  errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
4573 
4574  /*
4575  * Mark "abort pending" all subtransactions up to the target
4576  * subtransaction. The actual aborts will happen when control gets to
4577  * CommitTransactionCommand.
4578  */
4579  xact = CurrentTransactionState;
4580  for (;;)
4581  {
4582  if (xact == target)
4583  break;
4584  if (xact->blockState == TBLOCK_SUBINPROGRESS)
4586  else if (xact->blockState == TBLOCK_SUBABORT)
4588  else
4589  elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4591  xact = xact->parent;
4592  Assert(PointerIsValid(xact));
4593  }
4594 
4595  /* And mark the target as "restart pending" */
4596  if (xact->blockState == TBLOCK_SUBINPROGRESS)
4597  xact->blockState = TBLOCK_SUBRESTART;
4598  else if (xact->blockState == TBLOCK_SUBABORT)
4600  else
4601  elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4603 }

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

5463 {
5464  TransactionState s;
5465  Size nxids = 0;
5466  Size i = 0;
5467  TransactionId *workspace;
5469 
5470  result = (SerializedTransactionState *) start_address;
5471 
5472  result->xactIsoLevel = XactIsoLevel;
5473  result->xactDeferrable = XactDeferrable;
5475  result->currentFullTransactionId =
5478 
5479  /*
5480  * If we're running in a parallel worker and launching a parallel worker
5481  * of our own, we can just pass along the information that was passed to
5482  * us.
5483  */
5484  if (nParallelCurrentXids > 0)
5485  {
5487  memcpy(&result->parallelCurrentXids[0], ParallelCurrentXids,
5489  return;
5490  }
5491 
5492  /*
5493  * OK, we need to generate a sorted list of XIDs that our workers should
5494  * view as current. First, figure out how many there are.
5495  */
5496  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5497  {
5499  nxids = add_size(nxids, 1);
5500  nxids = add_size(nxids, s->nChildXids);
5501  }
5503  <= maxsize);
5504 
5505  /* Copy them to our scratch space. */
5506  workspace = palloc(nxids * sizeof(TransactionId));
5507  for (s = CurrentTransactionState; s != NULL; s = s->parent)
5508  {
5510  workspace[i++] = XidFromFullTransactionId(s->fullTransactionId);
5511  if (s->nChildXids > 0)
5512  memcpy(&workspace[i], s->childXids,
5513  s->nChildXids * sizeof(TransactionId));
5514  i += s->nChildXids;
5515  }
5516  Assert(i == nxids);
5517 
5518  /* Sort them. */
5519  qsort(workspace, nxids, sizeof(TransactionId), xidComparator);
5520 
5521  /* Copy data into output area. */
5522  result->nParallelCurrentXids = nxids;
5523  memcpy(&result->parallelCurrentXids[0], workspace,
5524  nxids * sizeof(TransactionId));
5525 }
int i
Definition: isn.c:73
void * palloc(Size size)
Definition: mcxt.c:1304
#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 845 of file xact.c.

846 {
848  xactStartTimestamp = xact_ts;
849  stmtStartTimestamp = stmt_ts;
850 }

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

Referenced by ParallelWorkerMain().

◆ StartParallelWorkerTransaction()

void StartParallelWorkerTransaction ( char *  tstatespace)

Definition at line 5533 of file xact.c.

5534 {
5536 
5538  StartTransaction();
5539 
5540  tstate = (SerializedTransactionState *) tstatespace;
5541  XactIsoLevel = tstate->xactIsoLevel;
5542  XactDeferrable = tstate->xactDeferrable;
5545  tstate->currentFullTransactionId;
5549 
5551 }
static void StartTransaction(void)
Definition: xact.c:1994

References Assert(), TransactionStateData::blockState, SerializedTransactionState::currentCommandId, currentCommandId, SerializedTransactionState::currentFullTransactionId, CurrentTransactionState, TransactionStateData::fullTransactionId, nParallelCurrentXids, SerializedTransactionState::nParallelCurrentXids, ParallelCurrentXids, SerializedTransactionState::parallelCurrentXids, StartTransaction(), TBLOCK_DEFAULT, TBLOCK_PARALLEL_INPROGRESS, SerializedTransactionState::topFullTransactionId, XactDeferrable, SerializedTransactionState::xactDeferrable, XactIsoLevel, SerializedTransactionState::xactIsoLevel, and XactTopFullTransactionId.

Referenced by ParallelWorkerMain().

◆ StartTransactionCommand()

void StartTransactionCommand ( void  )

Definition at line 2955 of file xact.c.

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

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

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

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

Referenced by fmgr_sql().

◆ TransactionBlockStatusCode()

char TransactionBlockStatusCode ( void  )

Definition at line 4924 of file xact.c.

4925 {
4927 
4928  switch (s->blockState)
4929  {
4930  case TBLOCK_DEFAULT:
4931  case TBLOCK_STARTED:
4932  return 'I'; /* idle --- not in transaction */
4933  case TBLOCK_BEGIN:
4934  case TBLOCK_SUBBEGIN:
4935  case TBLOCK_INPROGRESS:
4938  case TBLOCK_SUBINPROGRESS:
4939  case TBLOCK_END:
4940  case TBLOCK_SUBRELEASE:
4941  case TBLOCK_SUBCOMMIT:
4942  case TBLOCK_PREPARE:
4943  return 'T'; /* in transaction */
4944  case TBLOCK_ABORT:
4945  case TBLOCK_SUBABORT:
4946  case TBLOCK_ABORT_END:
4947  case TBLOCK_SUBABORT_END:
4948  case TBLOCK_ABORT_PENDING:
4950  case TBLOCK_SUBRESTART:
4952  return 'E'; /* in failed transaction */
4953  }
4954 
4955  /* should never get here */
4956  elog(FATAL, "invalid transaction block state: %s",
4958  return 0; /* keep compiler quiet */
4959 }

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

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

3800 {
3801  SubXactCallbackItem *item;
3802  SubXactCallbackItem *prev;
3803 
3804  prev = NULL;
3805  for (item = SubXact_callbacks; item; prev = item, item = item->next)
3806  {
3807  if (item->callback == callback && item->arg == arg)
3808  {
3809  if (prev)
3810  prev->next = item->next;
3811  else
3812  SubXact_callbacks = item->next;
3813  pfree(item);
3814  break;
3815  }
3816  }
3817 }
void pfree(void *pointer)
Definition: mcxt.c:1508

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

◆ UnregisterXactCallback()

void UnregisterXactCallback ( XactCallback  callback,
void *  arg 
)

Definition at line 3739 of file xact.c.

3740 {
3741  XactCallbackItem *item;
3742  XactCallbackItem *prev;
3743 
3744  prev = NULL;
3745  for (item = Xact_callbacks; item; prev = item, item = item->next)
3746  {
3747  if (item->callback == callback && item->arg == arg)
3748  {
3749  if (prev)
3750  prev->next = item->next;
3751  else
3752  Xact_callbacks = item->next;
3753  pfree(item);
3754  break;
3755  }
3756  }
3757 }

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

◆ UserAbortTransactionBlock()

void UserAbortTransactionBlock ( bool  chain)

Definition at line 4126 of file xact.c.

4127 {
4129 
4130  switch (s->blockState)
4131  {
4132  /*
4133  * We are inside a transaction block and we got a ROLLBACK command
4134  * from the user, so tell CommitTransactionCommand to abort and
4135  * exit the transaction block.
4136  */
4137  case TBLOCK_INPROGRESS:
4139  break;
4140 
4141  /*
4142  * We are inside a failed transaction block and we got a ROLLBACK
4143  * command from the user. Abort processing is already done, so
4144  * CommitTransactionCommand just has to cleanup and go back to
4145  * idle state.
4146  */
4147  case TBLOCK_ABORT:
4149  break;
4150 
4151  /*
4152  * We are inside a subtransaction. Mark everything up to top
4153  * level as exitable.
4154  */
4155  case TBLOCK_SUBINPROGRESS:
4156  case TBLOCK_SUBABORT:
4157  while (s->parent != NULL)
4158  {
4159  if (s->blockState == TBLOCK_SUBINPROGRESS)
4161  else if (s->blockState == TBLOCK_SUBABORT)
4163  else
4164  elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4166  s = s->parent;
4167  }
4168  if (s->blockState == TBLOCK_INPROGRESS)
4170  else if (s->blockState == TBLOCK_ABORT)
4172  else
4173  elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4175  break;
4176 
4177  /*
4178  * The user issued ABORT when not inside a transaction. For
4179  * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
4180  * The upcoming call to CommitTransactionCommand() will then put
4181  * us back into the default state. For ROLLBACK AND CHAIN, error.
4182  *
4183  * We do the same thing with ABORT inside an implicit transaction,
4184  * although in this case we might be rolling back actual database
4185  * state changes. (It's debatable whether we should issue a
4186  * WARNING in this case, but we have done so historically.)
4187  */
4188  case TBLOCK_STARTED:
4190  if (chain)
4191  ereport(ERROR,
4192  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4193  /* translator: %s represents an SQL statement name */
4194  errmsg("%s can only be used in transaction blocks",
4195  "ROLLBACK AND CHAIN")));
4196  else
4197  ereport(WARNING,
4198  (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4199  errmsg("there is no transaction in progress")));
4201  break;
4202 
4203  /*
4204  * The user issued an ABORT that somehow ran inside a parallel
4205  * worker. We can't cope with that.
4206  */
4208  ereport(FATAL,
4209  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4210  errmsg("cannot abort during a parallel operation")));
4211  break;
4212 
4213  /* These cases are invalid. */
4214  case TBLOCK_DEFAULT:
4215  case TBLOCK_BEGIN:
4216  case TBLOCK_SUBBEGIN:
4217  case TBLOCK_END:
4218  case TBLOCK_SUBRELEASE:
4219  case TBLOCK_SUBCOMMIT:
4220  case TBLOCK_ABORT_END:
4221  case TBLOCK_SUBABORT_END:
4222  case TBLOCK_ABORT_PENDING:
4224  case TBLOCK_SUBRESTART:
4226  case TBLOCK_PREPARE:
4227  elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4229  break;
4230  }
4231 
4234 
4235  s->chain = chain;
4236 }

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

3630 {
3631  CheckTransactionBlock(isTopLevel, false, stmtType);
3632 }

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

6286 {
6287  uint8 info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
6288 
6289  /* Backup blocks are not used in xact records */
6290  Assert(!XLogRecHasAnyBlockRefs(record));
6291 
6292  if (info == XLOG_XACT_COMMIT)
6293  {
6294  xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6295  xl_xact_parsed_commit parsed;
6296 
6297  ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6298  xact_redo_commit(&parsed, XLogRecGetXid(record),
6299  record->EndRecPtr, XLogRecGetOrigin(record));
6300  }
6301  else if (info == XLOG_XACT_COMMIT_PREPARED)
6302  {
6303  xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6304  xl_xact_parsed_commit parsed;
6305 
6306  ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6307  xact_redo_commit(&parsed, parsed.twophase_xid,
6308  record->EndRecPtr, XLogRecGetOrigin(record));
6309 
6310  /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6311  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6312  PrepareRedoRemove(parsed.twophase_xid, false);
6313  LWLockRelease(TwoPhaseStateLock);
6314  }
6315  else if (info == XLOG_XACT_ABORT)
6316  {
6317  xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6318  xl_xact_parsed_abort parsed;
6319 
6320  ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6321  xact_redo_abort(&parsed, XLogRecGetXid(record),
6322  record->EndRecPtr, XLogRecGetOrigin(record));
6323  }
6324  else if (info == XLOG_XACT_ABORT_PREPARED)
6325  {
6326  xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6327  xl_xact_parsed_abort parsed;
6328 
6329  ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6330  xact_redo_abort(&parsed, parsed.twophase_xid,
6331  record->EndRecPtr, XLogRecGetOrigin(record));
6332 
6333  /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6334  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6335  PrepareRedoRemove(parsed.twophase_xid, false);
6336  LWLockRelease(TwoPhaseStateLock);
6337  }
6338  else if (info == XLOG_XACT_PREPARE)
6339  {
6340  /*
6341  * Store xid and start/end pointers of the WAL record in TwoPhaseState
6342  * gxact entry.
6343  */
6344  LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6346  record->ReadRecPtr,
6347  record->EndRecPtr,
6348  XLogRecGetOrigin(record));
6349  LWLockRelease(TwoPhaseStateLock);
6350  }
6351  else if (info == XLOG_XACT_ASSIGNMENT)
6352  {
6354 
6357  xlrec->nsubxacts, xlrec->xsub);
6358  }
6359  else if (info == XLOG_XACT_INVALIDATIONS)
6360  {
6361  /*
6362  * XXX we do ignore this for now, what matters are invalidations
6363  * written into the commit record.
6364  */
6365  }
6366  else
6367  elog(PANIC, "xact_redo: unknown op code %u", info);
6368 }
#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:6052
static void xact_redo_abort(xl_xact_parsed_abort *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)
Definition: xact.c:6206
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 5712 of file xact.c.

5713 {
5715 
5716  if (s->nChildXids == 0)
5717  *ptr = NULL;
5718  else
5719  *ptr = s->childXids;
5720 
5721  return s->nChildXids;
5722 }

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

5914 {
5915  xl_xact_abort xlrec;
5916  xl_xact_xinfo xl_xinfo;
5917  xl_xact_subxacts xl_subxacts;
5918  xl_xact_relfilelocators xl_relfilelocators;
5919  xl_xact_stats_items xl_dropped_stats;
5920  xl_xact_twophase xl_twophase;
5921  xl_xact_dbinfo xl_dbinfo;
5922  xl_xact_origin xl_origin;
5923 
5924  uint8 info;
5925 
5926  Assert(CritSectionCount > 0);
5927 
5928  xl_xinfo.xinfo = 0;
5929 
5930  /* decide between a plain and 2pc abort */
5931  if (!TransactionIdIsValid(twophase_xid))
5932  info = XLOG_XACT_ABORT;
5933  else
5934  info = XLOG_XACT_ABORT_PREPARED;
5935 
5936 
5937  /* First figure out and collect all the information needed */
5938 
5939  xlrec.xact_time = abort_time;
5940 
5941  if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5942  xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5943 
5944  if (nsubxacts > 0)
5945  {
5946  xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5947  xl_subxacts.nsubxacts = nsubxacts;
5948  }
5949 
5950  if (nrels > 0)
5951  {
5953  xl_relfilelocators.nrels = nrels;
5954  info |= XLR_SPECIAL_REL_UPDATE;
5955  }
5956 
5957  if (ndroppedstats > 0)
5958  {
5959  xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5960  xl_dropped_stats.nitems = ndroppedstats;
5961  }
5962 
5963  if (TransactionIdIsValid(twophase_xid))
5964  {
5965  xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5966  xl_twophase.xid = twophase_xid;
5967  Assert(twophase_gid != NULL);
5968 
5969  if (XLogLogicalInfoActive())
5970  xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5971  }
5972 
5973  if (TransactionIdIsValid(twophase_xid) && XLogLogicalInfoActive())
5974  {
5975  xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5976  xl_dbinfo.dbId = MyDatabaseId;
5977  xl_dbinfo.tsId = MyDatabaseTableSpace;
5978  }
5979 
5980  /*
5981  * Dump transaction origin information. We need this during recovery to
5982  * update the replication origin progress.
5983  */
5985  {
5986  xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5987 
5990  }
5991 
5992  if (xl_xinfo.xinfo != 0)
5993  info |= XLOG_XACT_HAS_INFO;
5994 
5995  /* Then include all the collected data into the abort record. */
5996 
5997  XLogBeginInsert();
5998 
5999  XLogRegisterData((char *) (&xlrec), MinSizeOfXactAbort);
6000 
6001  if (xl_xinfo.xinfo != 0)
6002  XLogRegisterData((char *) (&xl_xinfo), sizeof(xl_xinfo));
6003 
6004  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
6005  XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
6006 
6007  if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
6008  {
6009  XLogRegisterData((char *) (&xl_subxacts),
6011  XLogRegisterData((char *) subxacts,
6012  nsubxacts * sizeof(TransactionId));
6013  }
6014 
6015  if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
6016  {
6017  XLogRegisterData((char *) (&xl_relfilelocators),
6019  XLogRegisterData((char *) rels,
6020  nrels * sizeof(RelFileLocator));
6021  }
6022 
6023  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
6024  {
6025  XLogRegisterData((char *) (&xl_dropped_stats),
6027  XLogRegisterData((char *) droppedstats,
6028  ndroppedstats * sizeof(xl_xact_stats_item));
6029  }
6030 
6031  if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
6032  {
6033  XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
6034  if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
6035  XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
6036  }
6037 
6038  if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
6039  XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
6040 
6041  /* Include the replication origin */
6043 
6044  return XLogInsert(RM_XACT_ID, info);
6045 }
#define unconstify(underlying_type, expr)
Definition: c.h:1232
Oid MyDatabaseTableSpace
Definition: globals.c:93
volatile uint32 CritSectionCount
Definition: globals.c:43
Oid MyDatabaseId
Definition: globals.c:91
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 5736 of file xact.c.

5744 {
5745  xl_xact_commit xlrec;
5746  xl_xact_xinfo xl_xinfo;
5747  xl_xact_dbinfo xl_dbinfo;
5748  xl_xact_subxacts xl_subxacts;
5749  xl_xact_relfilelocators xl_relfilelocators;
5750  xl_xact_stats_items xl_dropped_stats;
5751  xl_xact_invals xl_invals;
5752  xl_xact_twophase xl_twophase;
5753  xl_xact_origin xl_origin;
5754  uint8 info;
5755 
5756  Assert(CritSectionCount > 0);
5757 
5758  xl_xinfo.xinfo = 0;
5759 
5760  /* decide between a plain and 2pc commit */
5761  if (!TransactionIdIsValid(twophase_xid))
5762  info = XLOG_XACT_COMMIT;
5763  else
5765 
5766  /* First figure out and collect all the information needed */
5767 
5768  xlrec.xact_time = commit_time;
5769 
5770  if (relcacheInval)
5772  if (forceSyncCommit)
5774  if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5775  xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5776 
5777  /*
5778  * Check if the caller would like to ask standbys for immediate feedback
5779  * once this commit is applied.
5780  */
5783 
5784  /*
5785  * Relcache invalidations requires information about the current database
5786  * and so does logical decoding.
5787  */
5788  if (nmsgs > 0 || XLogLogicalInfoActive())
5789  {
5790  xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5791  xl_dbinfo.dbId = MyDatabaseId;
5792  xl_dbinfo.tsId = MyDatabaseTableSpace;
5793  }
5794 
5795  if (nsubxacts > 0)
5796  {
5797  xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5798  xl_subxacts.nsubxacts = nsubxacts;
5799  }
5800 
5801  if (nrels > 0)
5802  {
5804  xl_relfilelocators.nrels = nrels;
5805  info |= XLR_SPECIAL_REL_UPDATE;
5806  }
5807 
5808  if (ndroppedstats > 0)
5809  {
5810  xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5811  xl_dropped_stats.nitems = ndroppedstats;
5812  }
5813 
5814  if (nmsgs > 0)
5815  {
5816  xl_xinfo.xinfo |= XACT_XINFO_HAS_INVALS;
5817  xl_invals.nmsgs = nmsgs;
5818  }
5819 
5820  if (TransactionIdIsValid(twophase_xid))
5821  {
5822  xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5823  xl_twophase.xid = twophase_xid;
5824  Assert(twophase_gid != NULL);
5825 
5826  if (XLogLogicalInfoActive())
5827  xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5828  }
5829 
5830  /* dump transaction origin information */
5832  {
5833  xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5834 
5837  }
5838 
5839  if (xl_xinfo.xinfo != 0)
5840  info |= XLOG_XACT_HAS_INFO;
5841 
5842  /* Then include all the collected data into the commit record. */
5843 
5844  XLogBeginInsert();
5845 
5846  XLogRegisterData((char *) (&xlrec), sizeof(xl_xact_commit));
5847 
5848  if (xl_xinfo.xinfo != 0)
5849  XLogRegisterData((char *) (&xl_xinfo.xinfo), sizeof(xl_xinfo.xinfo));
5850 
5851  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
5852  XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
5853 
5854  if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
5855  {
5856  XLogRegisterData((char *) (&xl_subxacts),
5858  XLogRegisterData((char *) subxacts,
5859  nsubxacts * sizeof(TransactionId));
5860  }
5861 
5862  if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
5863  {
5864  XLogRegisterData((char *) (&xl_relfilelocators),
5866  XLogRegisterData((char *) rels,
5867  nrels * sizeof(RelFileLocator));
5868  }
5869 
5870  if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
5871  {
5872  XLogRegisterData((char *) (&xl_dropped_stats),
5874  XLogRegisterData((char *) droppedstats,
5875  ndroppedstats * sizeof(xl_xact_stats_item));
5876  }
5877 
5878  if (xl_xinfo.xinfo & XACT_XINFO_HAS_INVALS)
5879  {
5880  XLogRegisterData((char *) (&xl_invals), MinSizeOfXactInvals);
5881  XLogRegisterData((char *) msgs,
5882  nmsgs * sizeof(SharedInvalidationMessage));
5883  }
5884 
5885  if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
5886  {
5887  XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
5888  if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
5889  XLogRegisterData(unconstify(char *, twophase_gid), strlen(twophase_gid) + 1);
5890  }
5891 
5892  if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
5893  XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
5894 
5895  /* we allow filtering by xacts */
5897 
5898  return XLogInsert(RM_XACT_ID, info);
5899 }
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