#include "postgres.h"
#include <time.h>
#include <unistd.h>
#include "access/commit_ts.h"
#include "access/multixact.h"
#include "access/parallel.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "catalog/catalog.h"
#include "catalog/namespace.h"
#include "catalog/storage.h"
#include "commands/async.h"
#include "commands/tablecmds.h"
#include "commands/trigger.h"
#include "executor/spi.h"
#include "libpq/be-fsstubs.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "replication/logical.h"
#include "replication/logicallauncher.h"
#include "replication/origin.h"
#include "replication/syncrep.h"
#include "replication/walsender.h"
#include "storage/condition_variable.h"
#include "storage/fd.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/sinvaladt.h"
#include "storage/smgr.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/combocid.h"
#include "utils/guc.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/relmapper.h"
#include "utils/snapmgr.h"
#include "utils/timeout.h"
#include "utils/timestamp.h"
#include "pg_trace.h"

Include dependency graph for xact.c:

Data Structures
struct	TransactionStateData

struct	XactCallbackItem

struct	SubXactCallbackItem

Typedefs
typedef enum TransState	TransState

typedef enum TBlockState	TBlockState

typedef struct TransactionStateData	TransactionStateData

typedef TransactionStateData *	TransactionState

typedef struct XactCallbackItem	XactCallbackItem

typedef struct SubXactCallbackItem	SubXactCallbackItem

Functions
static void	AssignTransactionId (TransactionState s)

static void	AbortTransaction (void)

static void	AtAbort_Memory (void)

static void	AtCleanup_Memory (void)

static void	AtAbort_ResourceOwner (void)

static void	AtCCI_LocalCache (void)

static void	AtCommit_Memory (void)

static void	AtStart_Cache (void)

static void	AtStart_Memory (void)

static void	AtStart_ResourceOwner (void)

static void	CallXactCallbacks (XactEvent event)

static void	CallSubXactCallbacks (SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid)

static void	CleanupTransaction (void)

static void	CheckTransactionChain (bool isTopLevel, bool throwError, const char *stmtType)

static void	CommitTransaction (void)

static TransactionId	RecordTransactionAbort (bool isSubXact)

static void	StartTransaction (void)

static void	StartSubTransaction (void)

static void	CommitSubTransaction (void)

static void	AbortSubTransaction (void)

static void	CleanupSubTransaction (void)

static void	PushTransaction (void)

static void	PopTransaction (void)

static void	AtSubAbort_Memory (void)

static void	AtSubCleanup_Memory (void)

static void	AtSubAbort_ResourceOwner (void)

static void	AtSubCommit_Memory (void)

static void	AtSubStart_Memory (void)

static void	AtSubStart_ResourceOwner (void)

static void	ShowTransactionState (const char *str)

static void	ShowTransactionStateRec (const char *str, TransactionState state)

static const char *	BlockStateAsString (TBlockState blockState)

static const char *	TransStateAsString (TransState state)

bool	IsTransactionState (void)

bool	IsAbortedTransactionBlockState (void)

TransactionId	GetTopTransactionId (void)

TransactionId	GetTopTransactionIdIfAny (void)

TransactionId	GetCurrentTransactionId (void)

TransactionId	GetCurrentTransactionIdIfAny (void)

void	MarkCurrentTransactionIdLoggedIfAny (void)

TransactionId	GetStableLatestTransactionId (void)

SubTransactionId	GetCurrentSubTransactionId (void)

bool	SubTransactionIsActive (SubTransactionId subxid)

CommandId	GetCurrentCommandId (bool used)

TimestampTz	GetCurrentTransactionStartTimestamp (void)

TimestampTz	GetCurrentStatementStartTimestamp (void)

TimestampTz	GetCurrentTransactionStopTimestamp (void)

void	SetCurrentStatementStartTimestamp (void)

static void	SetCurrentTransactionStopTimestamp (void)

int	GetCurrentTransactionNestLevel (void)

bool	TransactionIdIsCurrentTransactionId (TransactionId xid)

bool	TransactionStartedDuringRecovery (void)

void	EnterParallelMode (void)

void	ExitParallelMode (void)

bool	IsInParallelMode (void)

void	CommandCounterIncrement (void)

void	ForceSyncCommit (void)

static TransactionId	RecordTransactionCommit (void)

static void	AtSubCommit_childXids (void)

static void	AtSubAbort_childXids (void)

static void	PrepareTransaction (void)

void	StartTransactionCommand (void)

void	CommitTransactionCommand (void)

void	AbortCurrentTransaction (void)

void	PreventTransactionChain (bool isTopLevel, const char *stmtType)

void	WarnNoTransactionChain (bool isTopLevel, const char *stmtType)

void	RequireTransactionChain (bool isTopLevel, const char *stmtType)

bool	IsInTransactionChain (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)

void	BeginTransactionBlock (void)

bool	PrepareTransactionBlock (char *gid)

bool	EndTransactionBlock (void)

void	UserAbortTransactionBlock (void)

void	BeginImplicitTransactionBlock (void)

void	EndImplicitTransactionBlock (void)

void	DefineSavepoint (char *name)

void	ReleaseSavepoint (List *options)

void	RollbackToSavepoint (List *options)

void	BeginInternalSubTransaction (char *name)

void	ReleaseCurrentSubTransaction (void)

void	RollbackAndReleaseCurrentSubTransaction (void)

void	AbortOutOfAnyTransaction (void)

bool	IsTransactionBlock (void)

bool	IsTransactionOrTransactionBlock (void)

char	TransactionBlockStatusCode (void)

bool	IsSubTransaction (void)

Size	EstimateTransactionStateSpace (void)

void	SerializeTransactionState (Size maxsize, char *start_address)

void	StartParallelWorkerTransaction (char *tstatespace)

void	EndParallelWorkerTransaction (void)

int	xactGetCommittedChildren (TransactionId **ptr)

XLogRecPtr	XactLogCommitRecord (TimestampTz commit_time, int nsubxacts, TransactionId subxacts, int nrels, RelFileNode rels, int nmsgs, SharedInvalidationMessage *msgs, bool relcacheInval, bool forceSync, int xactflags, TransactionId twophase_xid)

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

static void	xact_redo_commit (xl_xact_parsed_commit *parsed, TransactionId xid, XLogRecPtr lsn, RepOriginId origin_id)

static void	xact_redo_abort (xl_xact_parsed_abort *parsed, TransactionId xid)

void	xact_redo (XLogReaderState *record)

Variables
int	DefaultXactIsoLevel = XACT_READ_COMMITTED

int	XactIsoLevel

bool	DefaultXactReadOnly = false

bool	XactReadOnly

bool	DefaultXactDeferrable = false

bool	XactDeferrable

int	synchronous_commit = SYNCHRONOUS_COMMIT_ON

TransactionId	XactTopTransactionId = InvalidTransactionId

int	nParallelCurrentXids = 0

TransactionId *	ParallelCurrentXids

int	MyXactFlags

static TransactionStateData	TopTransactionStateData

static int	nUnreportedXids

static TransactionId	unreportedXids [PGPROC_MAX_CACHED_SUBXIDS]

static TransactionState	CurrentTransactionState = &TopTransactionStateData

static SubTransactionId	currentSubTransactionId

static CommandId	currentCommandId

static bool	currentCommandIdUsed

static TimestampTz	xactStartTimestamp

static TimestampTz	stmtStartTimestamp

static TimestampTz	xactStopTimestamp

static char *	prepareGID

static bool	forceSyncCommit = false

static MemoryContext	TransactionAbortContext = NULL

static XactCallbackItem *	Xact_callbacks = NULL

static SubXactCallbackItem *	SubXact_callbacks = NULL

Typedef Documentation

typedef struct SubXactCallbackItem SubXactCallbackItem

typedef enum TBlockState TBlockState

typedef TransactionStateData* TransactionState

Definition at line 195 of file xact.c.

typedef struct TransactionStateData TransactionStateData

typedef enum TransState TransState

typedef struct XactCallbackItem XactCallbackItem

Enumeration Type Documentation

enum TBlockState

Enumerator
TBLOCK_DEFAULT
TBLOCK_STARTED
TBLOCK_BEGIN
TBLOCK_INPROGRESS
TBLOCK_IMPLICIT_INPROGRESS
TBLOCK_PARALLEL_INPROGRESS
TBLOCK_END
TBLOCK_ABORT
TBLOCK_ABORT_END
TBLOCK_ABORT_PENDING
TBLOCK_PREPARE
TBLOCK_SUBBEGIN
TBLOCK_SUBINPROGRESS
TBLOCK_SUBRELEASE
TBLOCK_SUBCOMMIT
TBLOCK_SUBABORT
TBLOCK_SUBABORT_END
TBLOCK_SUBABORT_PENDING
TBLOCK_SUBRESTART
TBLOCK_SUBABORT_RESTART

Definition at line 139 of file xact.c.

 {
     /* not-in-transaction-block states */
     TBLOCK_DEFAULT,             /* idle */
     TBLOCK_STARTED,             /* running single-query transaction */
 
     /* transaction block states */
     TBLOCK_BEGIN,               /* starting transaction block */
     TBLOCK_INPROGRESS,          /* live transaction */
     TBLOCK_IMPLICIT_INPROGRESS, /* live transaction after implicit BEGIN */
     TBLOCK_PARALLEL_INPROGRESS, /* live transaction inside parallel worker */
     TBLOCK_END,                 /* COMMIT received */
     TBLOCK_ABORT,               /* failed xact, awaiting ROLLBACK */
     TBLOCK_ABORT_END,           /* failed xact, ROLLBACK received */
     TBLOCK_ABORT_PENDING,       /* live xact, ROLLBACK received */
     TBLOCK_PREPARE,             /* live xact, PREPARE received */
 
     /* subtransaction states */
     TBLOCK_SUBBEGIN,            /* starting a subtransaction */
     TBLOCK_SUBINPROGRESS,       /* live subtransaction */
     TBLOCK_SUBRELEASE,          /* RELEASE received */
     TBLOCK_SUBCOMMIT,           /* COMMIT received while TBLOCK_SUBINPROGRESS */
     TBLOCK_SUBABORT,            /* failed subxact, awaiting ROLLBACK */
     TBLOCK_SUBABORT_END,        /* failed subxact, ROLLBACK received */
     TBLOCK_SUBABORT_PENDING,    /* live subxact, ROLLBACK received */
     TBLOCK_SUBRESTART,          /* live subxact, ROLLBACK TO received */
     TBLOCK_SUBABORT_RESTART     /* failed subxact, ROLLBACK TO received */
 } TBlockState;

enum TransState

Enumerator
TRANS_DEFAULT
TRANS_START
TRANS_INPROGRESS
TRANS_COMMIT
TRANS_ABORT
TRANS_PREPARE

Definition at line 123 of file xact.c.

 {
     TRANS_DEFAULT,              /* idle */
     TRANS_START,                /* transaction starting */
     TRANS_INPROGRESS,           /* inside a valid transaction */
     TRANS_COMMIT,               /* commit in progress */
     TRANS_ABORT,                /* abort in progress */
     TRANS_PREPARE               /* prepare in progress */
 } TransState;

Function Documentation

void AbortCurrentTransaction ( void )

Definition at line 2984 of file xact.c.

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

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

 {
     TransactionState s = CurrentTransactionState;
 
     switch (s->blockState)
     {
         case TBLOCK_DEFAULT:
             if (s->state == TRANS_DEFAULT)
             {
                 /* we are idle, so nothing to do */
             }
             else
             {
                 /*
                  * We can get here after an error during transaction start
                  * (state will be TRANS_START).  Need to clean up the
                  * incompletely started transaction.  First, adjust the
                  * low-level state to suppress warning message from
                  * AbortTransaction.
                  */
                 if (s->state == TRANS_START)
                     s->state = TRANS_INPROGRESS;
                 AbortTransaction();
                 CleanupTransaction();
             }
             break;
 
             /*
              * If we aren't in a transaction block, we just do the basic abort
              * & cleanup transaction.  For this purpose, we treat an implicit
              * transaction block as if it were a simple statement.
              */
         case TBLOCK_STARTED:
         case TBLOCK_IMPLICIT_INPROGRESS:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * If we are in TBLOCK_BEGIN it means something screwed up right
              * after reading "BEGIN TRANSACTION".  We assume that the user
              * will interpret the error as meaning the BEGIN failed to get him
              * into a transaction block, so we should abort and return to idle
              * state.
              */
         case TBLOCK_BEGIN:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are somewhere in a transaction block and we've gotten a
              * failure, so we abort the transaction and set up the persistent
              * ABORT state.  We will stay in ABORT until we get a ROLLBACK.
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_PARALLEL_INPROGRESS:
             AbortTransaction();
             s->blockState = TBLOCK_ABORT;
             /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
             break;
 
             /*
              * Here, we failed while trying to COMMIT.  Clean up the
              * transaction and return to idle state (we do not want to stay in
              * the transaction).
              */
         case TBLOCK_END:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * Here, we are already in an aborted transaction state and are
              * waiting for a ROLLBACK, but for some reason we failed again! So
              * we just remain in the abort state.
              */
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
             break;
 
             /*
              * We are in a failed transaction and we got the ROLLBACK command.
              * We have already aborted, we just need to cleanup and go to idle
              * state.
              */
         case TBLOCK_ABORT_END:
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are in a live transaction and we got a ROLLBACK command.
              * Abort, cleanup, go to idle state.
              */
         case TBLOCK_ABORT_PENDING:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * Here, we failed while trying to PREPARE.  Clean up the
              * transaction and return to idle state (we do not want to stay in
              * the transaction).
              */
         case TBLOCK_PREPARE:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We got an error inside a subtransaction.  Abort just the
              * subtransaction, and go to the persistent SUBABORT state until
              * we get ROLLBACK.
              */
         case TBLOCK_SUBINPROGRESS:
             AbortSubTransaction();
             s->blockState = TBLOCK_SUBABORT;
             break;
 
             /*
              * If we failed while trying to create a subtransaction, clean up
              * the broken subtransaction and abort the parent.  The same
              * applies if we get a failure while ending a subtransaction.
              */
         case TBLOCK_SUBBEGIN:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
             AbortSubTransaction();
             CleanupSubTransaction();
             AbortCurrentTransaction();
             break;
 
             /*
              * Same as above, except the Abort() was already done.
              */
         case TBLOCK_SUBABORT_END:
         case TBLOCK_SUBABORT_RESTART:
             CleanupSubTransaction();
             AbortCurrentTransaction();
             break;
     }
 }

void AbortOutOfAnyTransaction ( void )

Definition at line 4343 of file xact.c.

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

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

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

static void AbortSubTransaction ( void )

static

Definition at line 4689 of file xact.c.

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), CommitTransactionCommand(), and RollbackAndReleaseCurrentSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /* Make sure we have a valid memory context and resource owner */
     AtSubAbort_Memory();
     AtSubAbort_ResourceOwner();
 
     /*
      * Release any LW locks we might be holding as quickly as possible.
      * (Regular locks, however, must be held till we finish aborting.)
      * Releasing LW locks is critical since we might try to grab them again
      * while cleaning up!
      *
      * FIXME This may be incorrect --- Are there some locks we should keep?
      * Buffer locks, for example?  I don't think so but I'm not sure.
      */
     LWLockReleaseAll();
 
     pgstat_report_wait_end();
     pgstat_progress_end_command();
     AbortBufferIO();
     UnlockBuffers();
 
     /* Reset WAL record construction state */
     XLogResetInsertion();
 
     /*
      * Also clean up any open wait for lock, since the lock manager will choke
      * if we try to wait for another lock before doing this.
      */
     LockErrorCleanup();
 
     /*
      * If any timeout events are still active, make sure the timeout interrupt
      * is scheduled.  This covers possible loss of a timeout interrupt due to
      * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
      * We delay this till after LockErrorCleanup so that we don't uselessly
      * reschedule lock or deadlock check timeouts.
      */
     reschedule_timeouts();
 
     /*
      * Re-enable signals, in case we got here by longjmp'ing out of a signal
      * handler.  We do this fairly early in the sequence so that the timeout
      * infrastructure will be functional if needed while aborting.
      */
     PG_SETMASK(&UnBlockSig);
 
     /*
      * check the current transaction state
      */
     ShowTransactionState("AbortSubTransaction");
 
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "AbortSubTransaction while in %s state",
              TransStateAsString(s->state));
 
     s->state = TRANS_ABORT;
 
     /*
      * Reset user ID which might have been changed transiently.  (See notes in
      * AbortTransaction.)
      */
     SetUserIdAndSecContext(s->prevUser, s->prevSecContext);
 
     /* Exit from parallel mode, if necessary. */
     if (IsInParallelMode())
     {
         AtEOSubXact_Parallel(false, s->subTransactionId);
         s->parallelModeLevel = 0;
     }
 
     /*
      * We can skip all this stuff if the subxact failed before creating a
      * ResourceOwner...
      */
     if (s->curTransactionOwner)
     {
         AfterTriggerEndSubXact(false);
         AtSubAbort_Portals(s->subTransactionId,
                            s->parent->subTransactionId,
                            s->curTransactionOwner,
                            s->parent->curTransactionOwner);
         AtEOSubXact_LargeObject(false, s->subTransactionId,
                                 s->parent->subTransactionId);
         AtSubAbort_Notify();
 
         /* Advertise the fact that we aborted in pg_xact. */
         (void) RecordTransactionAbort(true);
 
         /* Post-abort cleanup */
         if (TransactionIdIsValid(s->transactionId))
             AtSubAbort_childXids();
 
         CallSubXactCallbacks(SUBXACT_EVENT_ABORT_SUB, s->subTransactionId,
                              s->parent->subTransactionId);
 
         ResourceOwnerRelease(s->curTransactionOwner,
                              RESOURCE_RELEASE_BEFORE_LOCKS,
                              false, false);
         AtEOSubXact_RelationCache(false, s->subTransactionId,
                                   s->parent->subTransactionId);
         AtEOSubXact_Inval(false);
         ResourceOwnerRelease(s->curTransactionOwner,
                              RESOURCE_RELEASE_LOCKS,
                              false, false);
         ResourceOwnerRelease(s->curTransactionOwner,
                              RESOURCE_RELEASE_AFTER_LOCKS,
                              false, false);
         AtSubAbort_smgr();
 
         AtEOXact_GUC(false, s->gucNestLevel);
         AtEOSubXact_SPI(false, s->subTransactionId);
         AtEOSubXact_on_commit_actions(false, s->subTransactionId,
                                       s->parent->subTransactionId);
         AtEOSubXact_Namespace(false, s->subTransactionId,
                               s->parent->subTransactionId);
         AtEOSubXact_Files(false, s->subTransactionId,
                           s->parent->subTransactionId);
         AtEOSubXact_HashTables(false, s->nestingLevel);
         AtEOSubXact_PgStat(false, s->nestingLevel);
         AtSubAbort_Snapshot(s->nestingLevel);
     }
 
     /*
      * Restore the upper transaction's read-only state, too.  This should be
      * redundant with GUC's cleanup but we may as well do it for consistency
      * with the commit case.
      */
     XactReadOnly = s->prevXactReadOnly;
 
     RESUME_INTERRUPTS();
 }

static void AbortTransaction ( void )

static

Definition at line 2444 of file xact.c.

References AbortBufferIO(), AfterTriggerEndXact(), Assert, AtAbort_Memory(), AtAbort_Notify(), AtAbort_Portals(), AtAbort_ResourceOwner(), AtAbort_Twophase(), AtEOXact_ApplyLauncher(), AtEOXact_Buffers(), AtEOXact_ComboCid(), AtEOXact_Files(), AtEOXact_GUC(), AtEOXact_HashTables(), AtEOXact_Inval(), AtEOXact_LargeObject(), AtEOXact_MultiXact(), AtEOXact_Namespace(), AtEOXact_on_commit_actions(), AtEOXact_Parallel(), AtEOXact_PgStat(), AtEOXact_RelationCache(), AtEOXact_RelationMap(), AtEOXact_SMgr(), AtEOXact_SPI(), TransactionStateData::blockState, CallXactCallbacks(), ConditionVariableCancelSleep(), CurrentTransactionState, elog, HOLD_INTERRUPTS, InvalidTransactionId, IsInParallelMode(), LockErrorCleanup(), LWLockReleaseAll(), PGPROC::lxid, MyProc, TransactionStateData::parallelModeLevel, TransactionStateData::parent, PG_SETMASK, pgstat_progress_end_command(), pgstat_report_wait_end(), pgstat_report_xact_timestamp(), TransactionStateData::prevSecContext, TransactionStateData::prevUser, ProcArrayEndTransaction(), RecordTransactionAbort(), reschedule_timeouts(), RESOURCE_RELEASE_AFTER_LOCKS, RESOURCE_RELEASE_BEFORE_LOCKS, RESOURCE_RELEASE_LOCKS, ResourceOwnerRelease(), RESUME_INTERRUPTS, SetUserIdAndSecContext(), smgrDoPendingDeletes(), TransactionStateData::state, TBLOCK_PARALLEL_INPROGRESS, TopTransactionResourceOwner, TRANS_ABORT, TRANS_INPROGRESS, TRANS_PREPARE, TransStateAsString(), UnBlockSig, UnlockBuffers(), WARNING, XACT_EVENT_ABORT, XACT_EVENT_PARALLEL_ABORT, XactLastRecEnd, XLogResetInsertion(), and XLogSetAsyncXactLSN().

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), and CommitTransactionCommand().

 {
     TransactionState s = CurrentTransactionState;
     TransactionId latestXid;
     bool        is_parallel_worker;
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /* Make sure we have a valid memory context and resource owner */
     AtAbort_Memory();
     AtAbort_ResourceOwner();
 
     /*
      * Release any LW locks we might be holding as quickly as possible.
      * (Regular locks, however, must be held till we finish aborting.)
      * Releasing LW locks is critical since we might try to grab them again
      * while cleaning up!
      */
     LWLockReleaseAll();
 
     /* Clear wait information and command progress indicator */
     pgstat_report_wait_end();
     pgstat_progress_end_command();
 
     /* Clean up buffer I/O and buffer context locks, too */
     AbortBufferIO();
     UnlockBuffers();
 
     /* Reset WAL record construction state */
     XLogResetInsertion();
 
     /* Cancel condition variable sleep */
     ConditionVariableCancelSleep();
 
     /*
      * Also clean up any open wait for lock, since the lock manager will choke
      * if we try to wait for another lock before doing this.
      */
     LockErrorCleanup();
 
     /*
      * If any timeout events are still active, make sure the timeout interrupt
      * is scheduled.  This covers possible loss of a timeout interrupt due to
      * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
      * We delay this till after LockErrorCleanup so that we don't uselessly
      * reschedule lock or deadlock check timeouts.
      */
     reschedule_timeouts();
 
     /*
      * Re-enable signals, in case we got here by longjmp'ing out of a signal
      * handler.  We do this fairly early in the sequence so that the timeout
      * infrastructure will be functional if needed while aborting.
      */
     PG_SETMASK(&UnBlockSig);
 
     /*
      * check the current transaction state
      */
     is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);
     if (s->state != TRANS_INPROGRESS && s->state != TRANS_PREPARE)
         elog(WARNING, "AbortTransaction while in %s state",
              TransStateAsString(s->state));
     Assert(s->parent == NULL);
 
     /*
      * set the current transaction state information appropriately during the
      * abort processing
      */
     s->state = TRANS_ABORT;
 
     /*
      * Reset user ID which might have been changed transiently.  We need this
      * to clean up in case control escaped out of a SECURITY DEFINER function
      * or other local change of CurrentUserId; therefore, the prior value of
      * SecurityRestrictionContext also needs to be restored.
      *
      * (Note: it is not necessary to restore session authorization or role
      * settings here because those can only be changed via GUC, and GUC will
      * take care of rolling them back if need be.)
      */
     SetUserIdAndSecContext(s->prevUser, s->prevSecContext);
 
     /* If in parallel mode, clean up workers and exit parallel mode. */
     if (IsInParallelMode())
     {
         AtEOXact_Parallel(false);
         s->parallelModeLevel = 0;
     }
 
     /*
      * do abort processing
      */
     AfterTriggerEndXact(false); /* 'false' means it's abort */
     AtAbort_Portals();
     AtEOXact_LargeObject(false);
     AtAbort_Notify();
     AtEOXact_RelationMap(false);
     AtAbort_Twophase();
 
     /*
      * Advertise the fact that we aborted in pg_xact (assuming that we got as
      * far as assigning an XID to advertise).  But if we're inside a parallel
      * worker, skip this; the user backend must be the one to write the abort
      * record.
      */
     if (!is_parallel_worker)
         latestXid = RecordTransactionAbort(false);
     else
     {
         latestXid = InvalidTransactionId;
 
         /*
          * Since the parallel master won't get our value of XactLastRecEnd in
          * this case, we nudge WAL-writer ourselves in this case.  See related
          * comments in RecordTransactionAbort for why this matters.
          */
         XLogSetAsyncXactLSN(XactLastRecEnd);
     }
 
     TRACE_POSTGRESQL_TRANSACTION_ABORT(MyProc->lxid);
 
     /*
      * Let others know about no transaction in progress by me. Note that this
      * must be done _before_ releasing locks we hold and _after_
      * RecordTransactionAbort.
      */
     ProcArrayEndTransaction(MyProc, latestXid);
 
     /*
      * Post-abort cleanup.  See notes in CommitTransaction() concerning
      * ordering.  We can skip all of it if the transaction failed before
      * creating a resource owner.
      */
     if (TopTransactionResourceOwner != NULL)
     {
         if (is_parallel_worker)
             CallXactCallbacks(XACT_EVENT_PARALLEL_ABORT);
         else
             CallXactCallbacks(XACT_EVENT_ABORT);
 
         ResourceOwnerRelease(TopTransactionResourceOwner,
                              RESOURCE_RELEASE_BEFORE_LOCKS,
                              false, true);
         AtEOXact_Buffers(false);
         AtEOXact_RelationCache(false);
         AtEOXact_Inval(false);
         AtEOXact_MultiXact();
         ResourceOwnerRelease(TopTransactionResourceOwner,
                              RESOURCE_RELEASE_LOCKS,
                              false, true);
         ResourceOwnerRelease(TopTransactionResourceOwner,
                              RESOURCE_RELEASE_AFTER_LOCKS,
                              false, true);
         smgrDoPendingDeletes(false);
 
         AtEOXact_GUC(false, 1);
         AtEOXact_SPI(false);
         AtEOXact_on_commit_actions(false);
         AtEOXact_Namespace(false, is_parallel_worker);
         AtEOXact_SMgr();
         AtEOXact_Files();
         AtEOXact_ComboCid();
         AtEOXact_HashTables(false);
         AtEOXact_PgStat(false);
         AtEOXact_ApplyLauncher(false);
         pgstat_report_xact_timestamp(0);
     }
 
     /*
      * State remains TRANS_ABORT until CleanupTransaction().
      */
     RESUME_INTERRUPTS();
 }

static void AssignTransactionId ( TransactionState s )

static

Definition at line 490 of file xact.c.

References Assert, CurrentResourceOwner, TransactionStateData::curTransactionOwner, TransactionStateData::didLogXid, elog, ERROR, GetNewTransactionId(), GetTopTransactionId(), IsInParallelMode(), IsParallelWorker, MinSizeOfXactAssignment, TransactionStateData::nestingLevel, xl_xact_assignment::nsubxacts, nUnreportedXids, palloc(), TransactionStateData::parent, pfree(), PGPROC_MAX_CACHED_SUBXIDS, RegisterPredicateLockingXid(), TransactionStateData::state, SubTransSetParent(), TRANS_INPROGRESS, TransactionStateData::transactionId, TransactionIdIsValid, unreportedXids, XactLockTableInsert(), XactTopTransactionId, XLOG_XACT_ASSIGNMENT, XLogBeginInsert(), XLogInsert(), XLogLogicalInfoActive, XLogRegisterData(), XLogStandbyInfoActive, and xl_xact_assignment::xtop.

Referenced by GetCurrentTransactionId(), and GetTopTransactionId().

 {
     bool        isSubXact = (s->parent != NULL);
     ResourceOwner currentOwner;
     bool        log_unknown_top = false;
 
     /* Assert that caller didn't screw up */
     Assert(!TransactionIdIsValid(s->transactionId));
     Assert(s->state == TRANS_INPROGRESS);
 
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for new XIDs at this point.
      */
     if (IsInParallelMode() || IsParallelWorker())
         elog(ERROR, "cannot assign XIDs during a parallel operation");
 
     /*
      * Ensure parent(s) have XIDs, so that a child always has an XID later
      * than its parent.  Musn't recurse here, or we might get a stack overflow
      * if we're at the bottom of a huge stack of subtransactions none of which
      * have XIDs yet.
      */
     if (isSubXact && !TransactionIdIsValid(s->parent->transactionId))
     {
         TransactionState p = s->parent;
         TransactionState *parents;
         size_t      parentOffset = 0;
 
         parents = palloc(sizeof(TransactionState) * s->nestingLevel);
         while (p != NULL && !TransactionIdIsValid(p->transactionId))
         {
             parents[parentOffset++] = p;
             p = p->parent;
         }
 
         /*
          * This is technically a recursive call, but the recursion will never
          * be more than one layer deep.
          */
         while (parentOffset != 0)
             AssignTransactionId(parents[--parentOffset]);
 
         pfree(parents);
     }
 
     /*
      * When wal_level=logical, guarantee that a subtransaction's xid can only
      * be seen in the WAL stream if its toplevel xid has been logged before.
      * If necessary we log an xact_assignment record with fewer than
      * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
      * for a transaction even though it appears in a WAL record, we just might
      * superfluously log something. That can happen when an xid is included
      * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
      * xl_standby_locks.
      */
     if (isSubXact && XLogLogicalInfoActive() &&
         !TopTransactionStateData.didLogXid)
         log_unknown_top = true;
 
     /*
      * Generate a new Xid and record it in PG_PROC and pg_subtrans.
      *
      * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
      * shared storage other than PG_PROC; because if there's no room for it in
      * PG_PROC, the subtrans entry is needed to ensure that other backends see
      * the Xid as "running".  See GetNewTransactionId.
      */
     s->transactionId = GetNewTransactionId(isSubXact);
     if (!isSubXact)
         XactTopTransactionId = s->transactionId;
 
     if (isSubXact)
         SubTransSetParent(s->transactionId, s->parent->transactionId);
 
     /*
      * If it's a top-level transaction, the predicate locking system needs to
      * be told about it too.
      */
     if (!isSubXact)
         RegisterPredicateLockingXid(s->transactionId);
 
     /*
      * Acquire lock on the transaction XID.  (We assume this cannot block.) We
      * have to ensure that the lock is assigned to the transaction's own
      * ResourceOwner.
      */
     currentOwner = CurrentResourceOwner;
     CurrentResourceOwner = s->curTransactionOwner;
 
     XactLockTableInsert(s->transactionId);
 
     CurrentResourceOwner = currentOwner;
 
     /*
      * Every PGPROC_MAX_CACHED_SUBXIDS assigned transaction ids within each
      * top-level transaction we issue a WAL record for the assignment. We
      * include the top-level xid and all the subxids that have not yet been
      * reported using XLOG_XACT_ASSIGNMENT records.
      *
      * This is required to limit the amount of shared memory required in a hot
      * standby server to keep track of in-progress XIDs. See notes for
      * RecordKnownAssignedTransactionIds().
      *
      * We don't keep track of the immediate parent of each subxid, only the
      * top-level transaction that each subxact belongs to. This is correct in
      * recovery only because aborted subtransactions are separately WAL
      * logged.
      *
      * This is correct even for the case where several levels above us didn't
      * have an xid assigned as we recursed up to them beforehand.
      */
     if (isSubXact && XLogStandbyInfoActive())
     {
         unreportedXids[nUnreportedXids] = s->transactionId;
         nUnreportedXids++;
 
         /*
          * ensure this test matches similar one in
          * RecoverPreparedTransactions()
          */
         if (nUnreportedXids >= PGPROC_MAX_CACHED_SUBXIDS ||
             log_unknown_top)
         {
             xl_xact_assignment xlrec;
 
             /*
              * xtop is always set by now because we recurse up transaction
              * stack to the highest unassigned xid and then come back down
              */
             xlrec.xtop = GetTopTransactionId();
             Assert(TransactionIdIsValid(xlrec.xtop));
             xlrec.nsubxacts = nUnreportedXids;
 
             XLogBeginInsert();
             XLogRegisterData((char *) &xlrec, MinSizeOfXactAssignment);
             XLogRegisterData((char *) unreportedXids,
                              nUnreportedXids * sizeof(TransactionId));
 
             (void) XLogInsert(RM_XACT_ID, XLOG_XACT_ASSIGNMENT);
 
             nUnreportedXids = 0;
             /* mark top, not current xact as having been logged */
             TopTransactionStateData.didLogXid = true;
         }
     }
 }

static void AtAbort_Memory ( void )

static

Definition at line 1634 of file xact.c.

References MemoryContextSwitchTo(), and TopMemoryContext.

Referenced by AbortOutOfAnyTransaction(), and AbortTransaction().

 {
     /*
      * Switch into TransactionAbortContext, which should have some free space
      * even if nothing else does.  We'll work in this context until we've
      * finished cleaning up.
      *
      * It is barely possible to get here when we've not been able to create
      * TransactionAbortContext yet; if so use TopMemoryContext.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextSwitchTo(TransactionAbortContext);
     else
         MemoryContextSwitchTo(TopMemoryContext);
 }

static void AtAbort_ResourceOwner ( void )

static

Definition at line 1666 of file xact.c.

References CurrentResourceOwner, and TopTransactionResourceOwner.

Referenced by AbortTransaction().

 {
     /*
      * Make sure we have a valid ResourceOwner, if possible (else it will be
      * NULL, which is OK)
      */
     CurrentResourceOwner = TopTransactionResourceOwner;
 }

static void AtCCI_LocalCache ( void )

static

Definition at line 1358 of file xact.c.

References AtCCI_RelationMap(), and CommandEndInvalidationMessages().

Referenced by CommandCounterIncrement().

 {
     /*
      * Make any pending relation map changes visible.  We must do this before
      * processing local sinval messages, so that the map changes will get
      * reflected into the relcache when relcache invals are processed.
      */
     AtCCI_RelationMap();
 
     /*
      * Make catalog changes visible to me for the next command.
      */
     CommandEndInvalidationMessages();
 }

static void AtCleanup_Memory ( void )

static

Definition at line 1724 of file xact.c.

References Assert, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), TransactionStateData::parent, TopMemoryContext, and TopTransactionContext.

Referenced by AbortOutOfAnyTransaction(), and CleanupTransaction().

 {
     Assert(CurrentTransactionState->parent == NULL);
 
     /*
      * Now that we're "out" of a transaction, have the system allocate things
      * in the top memory context instead of per-transaction contexts.
      */
     MemoryContextSwitchTo(TopMemoryContext);
 
     /*
      * Clear the special abort context for next time.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextResetAndDeleteChildren(TransactionAbortContext);
 
     /*
      * Release all transaction-local memory.
      */
     if (TopTransactionContext != NULL)
         MemoryContextDelete(TopTransactionContext);
     TopTransactionContext = NULL;
     CurTransactionContext = NULL;
     CurrentTransactionState->curTransactionContext = NULL;
 }

static void AtCommit_Memory ( void )

static

Definition at line 1377 of file xact.c.

References Assert, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextSwitchTo(), TopMemoryContext, and TopTransactionContext.

Referenced by CommitTransaction(), and PrepareTransaction().

 {
     /*
      * Now that we're "out" of a transaction, have the system allocate things
      * in the top memory context instead of per-transaction contexts.
      */
     MemoryContextSwitchTo(TopMemoryContext);
 
     /*
      * Release all transaction-local memory.
      */
     Assert(TopTransactionContext != NULL);
     MemoryContextDelete(TopTransactionContext);
     TopTransactionContext = NULL;
     CurTransactionContext = NULL;
     CurrentTransactionState->curTransactionContext = NULL;
 }

static void AtStart_Cache ( void )

static

Definition at line 978 of file xact.c.

References AcceptInvalidationMessages().

Referenced by StartTransaction().

 {
     AcceptInvalidationMessages();
 }

static void AtStart_Memory ( void )

static

Definition at line 987 of file xact.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextSwitchTo(), TopMemoryContext, and TopTransactionContext.

Referenced by StartTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * If this is the first time through, create a private context for
      * AbortTransaction to work in.  By reserving some space now, we can
      * insulate AbortTransaction from out-of-memory scenarios.  Like
      * ErrorContext, we set it up with slow growth rate and a nonzero minimum
      * size, so that space will be reserved immediately.
      */
     if (TransactionAbortContext == NULL)
         TransactionAbortContext =
             AllocSetContextCreate(TopMemoryContext,
                                   "TransactionAbortContext",
                                   32 * 1024,
                                   32 * 1024,
                                   32 * 1024);
 
     /*
      * We shouldn't have a transaction context already.
      */
     Assert(TopTransactionContext == NULL);
 
     /*
      * Create a toplevel context for the transaction.
      */
     TopTransactionContext =
         AllocSetContextCreate(TopMemoryContext,
                               "TopTransactionContext",
                               ALLOCSET_DEFAULT_SIZES);
 
     /*
      * In a top-level transaction, CurTransactionContext is the same as
      * TopTransactionContext.
      */
     CurTransactionContext = TopTransactionContext;
     s->curTransactionContext = CurTransactionContext;
 
     /* Make the CurTransactionContext active. */
     MemoryContextSwitchTo(CurTransactionContext);
 }

static void AtStart_ResourceOwner ( void )

static

Definition at line 1034 of file xact.c.

References Assert, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, ResourceOwnerCreate(), and TopTransactionResourceOwner.

Referenced by StartTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * We shouldn't have a transaction resource owner already.
      */
     Assert(TopTransactionResourceOwner == NULL);
 
     /*
      * Create a toplevel resource owner for the transaction.
      */
     s->curTransactionOwner = ResourceOwnerCreate(NULL, "TopTransaction");
 
     TopTransactionResourceOwner = s->curTransactionOwner;
     CurTransactionResourceOwner = s->curTransactionOwner;
     CurrentResourceOwner = s->curTransactionOwner;
 }

static void AtSubAbort_childXids ( void )

static

Definition at line 1692 of file xact.c.

References TransactionStateData::childXids, CurrentTransactionState, TransactionStateData::maxChildXids, TransactionStateData::nChildXids, and pfree().

Referenced by AbortSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * We keep the child-XID arrays in TopTransactionContext (see
      * AtSubCommit_childXids).  This means we'd better free the array
      * explicitly at abort to avoid leakage.
      */
     if (s->childXids != NULL)
         pfree(s->childXids);
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
 
     /*
      * We could prune the unreportedXids array here. But we don't bother. That
      * would potentially reduce number of XLOG_XACT_ASSIGNMENT records but it
      * would likely introduce more CPU time into the more common paths, so we
      * choose not to do that.
      */
 }

static void AtSubAbort_Memory ( void )

static

Definition at line 1654 of file xact.c.

References Assert, and MemoryContextSwitchTo().

Referenced by AbortSubTransaction().

 {
     Assert(TransactionAbortContext != NULL);
 
     MemoryContextSwitchTo(TransactionAbortContext);
 }

static void AtSubAbort_ResourceOwner ( void )

static

Definition at line 1679 of file xact.c.

References CurrentResourceOwner, CurrentTransactionState, and TransactionStateData::curTransactionOwner.

Referenced by AbortSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     /* Make sure we have a valid ResourceOwner */
     CurrentResourceOwner = s->curTransactionOwner;
 }

static void AtSubCleanup_Memory ( void )

static

Definition at line 1760 of file xact.c.

References Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), and TransactionStateData::parent.

Referenced by CleanupSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parent != NULL);
 
     /* Make sure we're not in an about-to-be-deleted context */
     MemoryContextSwitchTo(s->parent->curTransactionContext);
     CurTransactionContext = s->parent->curTransactionContext;
 
     /*
      * Clear the special abort context for next time.
      */
     if (TransactionAbortContext != NULL)
         MemoryContextResetAndDeleteChildren(TransactionAbortContext);
 
     /*
      * Delete the subxact local memory contexts. Its CurTransactionContext can
      * go too (note this also kills CurTransactionContexts from any children
      * of the subxact).
      */
     if (s->curTransactionContext)
         MemoryContextDelete(s->curTransactionContext);
     s->curTransactionContext = NULL;
 }

static void AtSubCommit_childXids ( void )

static

Definition at line 1433 of file xact.c.

References Assert, TransactionStateData::childXids, CurrentTransactionState, ereport, errcode(), errmsg(), ERROR, MaxAllocSize, TransactionStateData::maxChildXids, MemoryContextAlloc(), Min, TransactionStateData::nChildXids, TransactionStateData::parent, pfree(), repalloc(), TopTransactionContext, and TransactionStateData::transactionId.

Referenced by CommitSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
     int         new_nChildXids;
 
     Assert(s->parent != NULL);
 
     /*
      * The parent childXids array will need to hold my XID and all my
      * childXids, in addition to the XIDs already there.
      */
     new_nChildXids = s->parent->nChildXids + s->nChildXids + 1;
 
     /* Allocate or enlarge the parent array if necessary */
     if (s->parent->maxChildXids < new_nChildXids)
     {
         int         new_maxChildXids;
         TransactionId *new_childXids;
 
         /*
          * Make it 2x what's needed right now, to avoid having to enlarge it
          * repeatedly. But we can't go above MaxAllocSize.  (The latter limit
          * is what ensures that we don't need to worry about integer overflow
          * here or in the calculation of new_nChildXids.)
          */
         new_maxChildXids = Min(new_nChildXids * 2,
                                (int) (MaxAllocSize / sizeof(TransactionId)));
 
         if (new_maxChildXids < new_nChildXids)
             ereport(ERROR,
                     (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                      errmsg("maximum number of committed subtransactions (%d) exceeded",
                             (int) (MaxAllocSize / sizeof(TransactionId)))));
 
         /*
          * We keep the child-XID arrays in TopTransactionContext; this avoids
          * setting up child-transaction contexts for what might be just a few
          * bytes of grandchild XIDs.
          */
         if (s->parent->childXids == NULL)
             new_childXids =
                 MemoryContextAlloc(TopTransactionContext,
                                    new_maxChildXids * sizeof(TransactionId));
         else
             new_childXids = repalloc(s->parent->childXids,
                                      new_maxChildXids * sizeof(TransactionId));
 
         s->parent->childXids = new_childXids;
         s->parent->maxChildXids = new_maxChildXids;
     }
 
     /*
      * Copy all my XIDs to parent's array.
      *
      * Note: We rely on the fact that the XID of a child always follows that
      * of its parent.  By copying the XID of this subtransaction before the
      * XIDs of its children, we ensure that the array stays ordered. Likewise,
      * all XIDs already in the array belong to subtransactions started and
      * subcommitted before us, so their XIDs must precede ours.
      */
     s->parent->childXids[s->parent->nChildXids] = s->transactionId;
 
     if (s->nChildXids > 0)
         memcpy(&s->parent->childXids[s->parent->nChildXids + 1],
                s->childXids,
                s->nChildXids * sizeof(TransactionId));
 
     s->parent->nChildXids = new_nChildXids;
 
     /* Release child's array to avoid leakage */
     if (s->childXids != NULL)
         pfree(s->childXids);
     /* We must reset these to avoid double-free if fail later in commit */
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
 }

static void AtSubCommit_Memory ( void )

static

Definition at line 1404 of file xact.c.

References Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, MemoryContextDelete(), MemoryContextIsEmpty(), MemoryContextSwitchTo(), and TransactionStateData::parent.

Referenced by CommitSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parent != NULL);
 
     /* Return to parent transaction level's memory context. */
     CurTransactionContext = s->parent->curTransactionContext;
     MemoryContextSwitchTo(CurTransactionContext);
 
     /*
      * Ordinarily we cannot throw away the child's CurTransactionContext,
      * since the data it contains will be needed at upper commit.  However, if
      * there isn't actually anything in it, we can throw it away.  This avoids
      * a small memory leak in the common case of "trivial" subxacts.
      */
     if (MemoryContextIsEmpty(s->curTransactionContext))
     {
         MemoryContextDelete(s->curTransactionContext);
         s->curTransactionContext = NULL;
     }
 }

static void AtSubStart_Memory ( void )

static

Definition at line 1062 of file xact.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), Assert, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, and MemoryContextSwitchTo().

Referenced by StartSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(CurTransactionContext != NULL);
 
     /*
      * Create a CurTransactionContext, which will be used to hold data that
      * survives subtransaction commit but disappears on subtransaction abort.
      * We make it a child of the immediate parent's CurTransactionContext.
      */
     CurTransactionContext = AllocSetContextCreate(CurTransactionContext,
                                                   "CurTransactionContext",
                                                   ALLOCSET_DEFAULT_SIZES);
     s->curTransactionContext = CurTransactionContext;
 
     /* Make the CurTransactionContext active. */
     MemoryContextSwitchTo(CurTransactionContext);
 }

static void AtSubStart_ResourceOwner ( void )

static

Definition at line 1086 of file xact.c.

References Assert, CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, TransactionStateData::parent, and ResourceOwnerCreate().

Referenced by StartSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     Assert(s->parent != NULL);
 
     /*
      * Create a resource owner for the subtransaction.  We make it a child of
      * the immediate parent's resource owner.
      */
     s->curTransactionOwner =
         ResourceOwnerCreate(s->parent->curTransactionOwner,
                             "SubTransaction");
 
     CurTransactionResourceOwner = s->curTransactionOwner;
     CurrentResourceOwner = s->curTransactionOwner;
 }

void BeginImplicitTransactionBlock ( void )

Definition at line 3779 of file xact.c.

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

Referenced by exec_simple_query().

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

void BeginInternalSubTransaction ( char * name )

Definition at line 4171 of file xact.c.

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

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

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * Workers synchronize transaction state at the beginning of each parallel
      * operation, so we can't account for new subtransactions after that
      * point. We might be able to make an exception for the type of
      * subtransaction established by this function, which is typically used in
      * contexts where we're going to release or roll back the subtransaction
      * before proceeding further, so that no enduring change to the
      * transaction state occurs. For now, however, we prohibit this case along
      * with all the others.
      */
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot start subtransactions during a parallel operation")));
 
     switch (s->blockState)
     {
         case TBLOCK_STARTED:
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_END:
         case TBLOCK_PREPARE:
         case TBLOCK_SUBINPROGRESS:
             /* Normal subtransaction start */
             PushTransaction();
             s = CurrentTransactionState;    /* changed by push */
 
             /*
              * Savepoint names, like the TransactionState block itself, live
              * in TopTransactionContext.
              */
             if (name)
                 s->name = MemoryContextStrdup(TopTransactionContext, name);
             break;
 
             /* These cases are invalid. */
         case TBLOCK_DEFAULT:
         case TBLOCK_BEGIN:
         case TBLOCK_PARALLEL_INPROGRESS:
         case TBLOCK_SUBBEGIN:
         case TBLOCK_SUBRELEASE:
         case TBLOCK_SUBCOMMIT:
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
         case TBLOCK_ABORT_END:
         case TBLOCK_SUBABORT_END:
         case TBLOCK_ABORT_PENDING:
         case TBLOCK_SUBABORT_PENDING:
         case TBLOCK_SUBRESTART:
         case TBLOCK_SUBABORT_RESTART:
             elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
     }
 
     CommitTransactionCommand();
     StartTransactionCommand();
 }

void BeginTransactionBlock ( void )

Definition at line 3413 of file xact.c.

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

Referenced by standard_ProcessUtility().

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

static const char * BlockStateAsString ( TBlockState blockState )

static

Definition at line 5147 of file xact.c.

References 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 BeginInternalSubTransaction(), BeginTransactionBlock(), CommitTransactionCommand(), DefineSavepoint(), EndTransactionBlock(), ReleaseCurrentSubTransaction(), ReleaseSavepoint(), RollbackAndReleaseCurrentSubTransaction(), RollbackToSavepoint(), ShowTransactionStateRec(), StartTransactionCommand(), TransactionBlockStatusCode(), and UserAbortTransactionBlock().

 {
     switch (blockState)
     {
         case TBLOCK_DEFAULT:
             return "DEFAULT";
         case TBLOCK_STARTED:
             return "STARTED";
         case TBLOCK_BEGIN:
             return "BEGIN";
         case TBLOCK_INPROGRESS:
             return "INPROGRESS";
         case TBLOCK_IMPLICIT_INPROGRESS:
             return "IMPLICIT_INPROGRESS";
         case TBLOCK_PARALLEL_INPROGRESS:
             return "PARALLEL_INPROGRESS";
         case TBLOCK_END:
             return "END";
         case TBLOCK_ABORT:
             return "ABORT";
         case TBLOCK_ABORT_END:
             return "ABORT END";
         case TBLOCK_ABORT_PENDING:
             return "ABORT PEND";
         case TBLOCK_PREPARE:
             return "PREPARE";
         case TBLOCK_SUBBEGIN:
             return "SUB BEGIN";
         case TBLOCK_SUBINPROGRESS:
             return "SUB INPROGRS";
         case TBLOCK_SUBRELEASE:
             return "SUB RELEASE";
         case TBLOCK_SUBCOMMIT:
             return "SUB COMMIT";
         case TBLOCK_SUBABORT:
             return "SUB ABORT";
         case TBLOCK_SUBABORT_END:
             return "SUB ABORT END";
         case TBLOCK_SUBABORT_PENDING:
             return "SUB ABRT PEND";
         case TBLOCK_SUBRESTART:
             return "SUB RESTART";
         case TBLOCK_SUBABORT_RESTART:
             return "SUB AB RESTRT";
     }
     return "UNRECOGNIZED";
 }

static void CallSubXactCallbacks	(	SubXactEvent	event,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

static

Definition at line 3392 of file xact.c.

References SubXactCallbackItem::arg, SubXactCallbackItem::callback, and SubXactCallbackItem::next.

Referenced by AbortSubTransaction(), CommitSubTransaction(), and StartSubTransaction().

 {
     SubXactCallbackItem *item;
 
     for (item = SubXact_callbacks; item; item = item->next)
         item->callback(event, mySubid, parentSubid, item->arg);
 }

static void CallXactCallbacks ( XactEvent event )

static

Definition at line 3337 of file xact.c.

References XactCallbackItem::arg, XactCallbackItem::callback, and XactCallbackItem::next.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

 {
     XactCallbackItem *item;
 
     for (item = Xact_callbacks; item; item = item->next)
         item->callback(event, item->arg);
 }

static void CheckTransactionChain	(	bool	isTopLevel,
		bool	throwError,
		const char *	stmtType
	)

static

Definition at line 3229 of file xact.c.

References ereport, errcode(), errmsg(), ERROR, IsSubTransaction(), IsTransactionBlock(), and WARNING.

Referenced by RequireTransactionChain(), and WarnNoTransactionChain().

 {
     /*
      * xact block already started?
      */
     if (IsTransactionBlock())
         return;
 
     /*
      * subtransaction?
      */
     if (IsSubTransaction())
         return;
 
     /*
      * inside a function call?
      */
     if (!isTopLevel)
         return;
 
     ereport(throwError ? ERROR : WARNING,
             (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
     /* translator: %s represents an SQL statement name */
              errmsg("%s can only be used in transaction blocks",
                     stmtType)));
     return;
 }

static void CleanupSubTransaction ( void )

static

Definition at line 4834 of file xact.c.

References AtSubCleanup_Memory(), AtSubCleanup_Portals(), CurrentResourceOwner, CurrentTransactionState, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog, TransactionStateData::parent, PopTransaction(), ResourceOwnerDelete(), ShowTransactionState(), TransactionStateData::state, TransactionStateData::subTransactionId, TRANS_ABORT, TRANS_DEFAULT, TransStateAsString(), and WARNING.

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), CommitTransactionCommand(), and RollbackAndReleaseCurrentSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     ShowTransactionState("CleanupSubTransaction");
 
     if (s->state != TRANS_ABORT)
         elog(WARNING, "CleanupSubTransaction while in %s state",
              TransStateAsString(s->state));
 
     AtSubCleanup_Portals(s->subTransactionId);
 
     CurrentResourceOwner = s->parent->curTransactionOwner;
     CurTransactionResourceOwner = s->parent->curTransactionOwner;
     if (s->curTransactionOwner)
         ResourceOwnerDelete(s->curTransactionOwner);
     s->curTransactionOwner = NULL;
 
     AtSubCleanup_Memory();
 
     s->state = TRANS_DEFAULT;
 
     PopTransaction();
 }

static void CleanupTransaction ( void )

static

Definition at line 2624 of file xact.c.

Referenced by AbortCurrentTransaction(), AbortOutOfAnyTransaction(), and CommitTransactionCommand().

 {
     TransactionState s = CurrentTransactionState;
 
     /*
      * State should still be TRANS_ABORT from AbortTransaction().
      */
     if (s->state != TRANS_ABORT)
         elog(FATAL, "CleanupTransaction: unexpected state %s",
              TransStateAsString(s->state));
 
     /*
      * do abort cleanup processing
      */
     AtCleanup_Portals();        /* now safe to release portal memory */
     AtEOXact_Snapshot(false, true); /* and release the transaction's snapshots */
 
     CurrentResourceOwner = NULL;    /* and resource owner */
     if (TopTransactionResourceOwner)
         ResourceOwnerDelete(TopTransactionResourceOwner);
     s->curTransactionOwner = NULL;
     CurTransactionResourceOwner = NULL;
     TopTransactionResourceOwner = NULL;
 
     AtCleanup_Memory();         /* and transaction memory */
 
     s->transactionId = InvalidTransactionId;
     s->subTransactionId = InvalidSubTransactionId;
     s->nestingLevel = 0;
     s->gucNestLevel = 0;
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
     s->parallelModeLevel = 0;
 
     XactTopTransactionId = InvalidTransactionId;
     nParallelCurrentXids = 0;
 
     /*
      * done with abort processing, set current transaction state back to
      * default
      */
     s->state = TRANS_DEFAULT;
 }

void CommandCounterIncrement ( void )

Definition at line 915 of file xact.c.

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

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

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

static void CommitSubTransaction ( void )

static

Definition at line 4581 of file xact.c.

Referenced by CommitTransactionCommand(), and ReleaseCurrentSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     ShowTransactionState("CommitSubTransaction");
 
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "CommitSubTransaction while in %s state",
              TransStateAsString(s->state));
 
     /* Pre-commit processing goes here */
 
     CallSubXactCallbacks(SUBXACT_EVENT_PRE_COMMIT_SUB, s->subTransactionId,
                          s->parent->subTransactionId);
 
     /* If in parallel mode, clean up workers and exit parallel mode. */
     if (IsInParallelMode())
     {
         AtEOSubXact_Parallel(true, s->subTransactionId);
         s->parallelModeLevel = 0;
     }
 
     /* Do the actual "commit", such as it is */
     s->state = TRANS_COMMIT;
 
     /* Must CCI to ensure commands of subtransaction are seen as done */
     CommandCounterIncrement();
 
     /*
      * Prior to 8.4 we marked subcommit in clog at this point.  We now only
      * perform that step, if required, as part of the atomic update of the
      * whole transaction tree at top level commit or abort.
      */
 
     /* Post-commit cleanup */
     if (TransactionIdIsValid(s->transactionId))
         AtSubCommit_childXids();
     AfterTriggerEndSubXact(true);
     AtSubCommit_Portals(s->subTransactionId,
                         s->parent->subTransactionId,
                         s->parent->curTransactionOwner);
     AtEOSubXact_LargeObject(true, s->subTransactionId,
                             s->parent->subTransactionId);
     AtSubCommit_Notify();
 
     CallSubXactCallbacks(SUBXACT_EVENT_COMMIT_SUB, s->subTransactionId,
                          s->parent->subTransactionId);
 
     ResourceOwnerRelease(s->curTransactionOwner,
                          RESOURCE_RELEASE_BEFORE_LOCKS,
                          true, false);
     AtEOSubXact_RelationCache(true, s->subTransactionId,
                               s->parent->subTransactionId);
     AtEOSubXact_Inval(true);
     AtSubCommit_smgr();
 
     /*
      * The only lock we actually release here is the subtransaction XID lock.
      */
     CurrentResourceOwner = s->curTransactionOwner;
     if (TransactionIdIsValid(s->transactionId))
         XactLockTableDelete(s->transactionId);
 
     /*
      * Other locks should get transferred to their parent resource owner.
      */
     ResourceOwnerRelease(s->curTransactionOwner,
                          RESOURCE_RELEASE_LOCKS,
                          true, false);
     ResourceOwnerRelease(s->curTransactionOwner,
                          RESOURCE_RELEASE_AFTER_LOCKS,
                          true, false);
 
     AtEOXact_GUC(true, s->gucNestLevel);
     AtEOSubXact_SPI(true, s->subTransactionId);
     AtEOSubXact_on_commit_actions(true, s->subTransactionId,
                                   s->parent->subTransactionId);
     AtEOSubXact_Namespace(true, s->subTransactionId,
                           s->parent->subTransactionId);
     AtEOSubXact_Files(true, s->subTransactionId,
                       s->parent->subTransactionId);
     AtEOSubXact_HashTables(true, s->nestingLevel);
     AtEOSubXact_PgStat(true, s->nestingLevel);
     AtSubCommit_Snapshot(s->nestingLevel);
 
     /*
      * We need to restore the upper transaction's read-only state, in case the
      * upper is read-write while the child is read-only; GUC will incorrectly
      * think it should leave the child state in place.
      */
     XactReadOnly = s->prevXactReadOnly;
 
     CurrentResourceOwner = s->parent->curTransactionOwner;
     CurTransactionResourceOwner = s->parent->curTransactionOwner;
     ResourceOwnerDelete(s->curTransactionOwner);
     s->curTransactionOwner = NULL;
 
     AtSubCommit_Memory();
 
     s->state = TRANS_DEFAULT;
 
     PopTransaction();
 }

static void CommitTransaction ( void )

static

Definition at line 1933 of file xact.c.

Referenced by CommitTransactionCommand(), EndParallelWorkerTransaction(), EndRestoreBlobs(), restore_toc_entry(), and RestoreArchive().

 {
     TransactionState s = CurrentTransactionState;
     TransactionId latestXid;
     bool        is_parallel_worker;
 
     is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);
 
     /* Enforce parallel mode restrictions during parallel worker commit. */
     if (is_parallel_worker)
         EnterParallelMode();
 
     ShowTransactionState("CommitTransaction");
 
     /*
      * check the current transaction state
      */
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "CommitTransaction while in %s state",
              TransStateAsString(s->state));
     Assert(s->parent == NULL);
 
     /*
      * Do pre-commit processing that involves calling user-defined code, such
      * as triggers.  Since closing cursors could queue trigger actions,
      * triggers could open cursors, etc, we have to keep looping until there's
      * nothing left to do.
      */
     for (;;)
     {
         /*
          * Fire all currently pending deferred triggers.
          */
         AfterTriggerFireDeferred();
 
         /*
          * Close open portals (converting holdable ones into static portals).
          * If there weren't any, we are done ... otherwise loop back to check
          * if they queued deferred triggers.  Lather, rinse, repeat.
          */
         if (!PreCommit_Portals(false))
             break;
     }
 
     CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_PRE_COMMIT
                       : XACT_EVENT_PRE_COMMIT);
 
     /*
      * The remaining actions cannot call any user-defined code, so it's safe
      * to start shutting down within-transaction services.  But note that most
      * of this stuff could still throw an error, which would switch us into
      * the transaction-abort path.
      */
 
     /* If we might have parallel workers, clean them up now. */
     if (IsInParallelMode())
         AtEOXact_Parallel(true);
 
     /* Shut down the deferred-trigger manager */
     AfterTriggerEndXact(true);
 
     /*
      * Let ON COMMIT management do its thing (must happen after closing
      * cursors, to avoid dangling-reference problems)
      */
     PreCommit_on_commit_actions();
 
     /* close large objects before lower-level cleanup */
     AtEOXact_LargeObject(true);
 
     /*
      * Mark serializable transaction as complete for predicate locking
      * purposes.  This should be done as late as we can put it and still allow
      * errors to be raised for failure patterns found at commit.
      */
     PreCommit_CheckForSerializationFailure();
 
     /*
      * Insert notifications sent by NOTIFY commands into the queue.  This
      * should be late in the pre-commit sequence to minimize time spent
      * holding the notify-insertion lock.
      */
     PreCommit_Notify();
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /* Commit updates to the relation map --- do this as late as possible */
     AtEOXact_RelationMap(true);
 
     /*
      * set the current transaction state information appropriately during
      * commit processing
      */
     s->state = TRANS_COMMIT;
     s->parallelModeLevel = 0;
 
     if (!is_parallel_worker)
     {
         /*
          * We need to mark our XIDs as committed in pg_xact.  This is where we
          * durably commit.
          */
         latestXid = RecordTransactionCommit();
     }
     else
     {
         /*
          * We must not mark our XID committed; the parallel master is
          * responsible for that.
          */
         latestXid = InvalidTransactionId;
 
         /*
          * Make sure the master will know about any WAL we wrote before it
          * commits.
          */
         ParallelWorkerReportLastRecEnd(XactLastRecEnd);
     }
 
     TRACE_POSTGRESQL_TRANSACTION_COMMIT(MyProc->lxid);
 
     /*
      * Let others know about no transaction in progress by me. Note that this
      * must be done _before_ releasing locks we hold and _after_
      * RecordTransactionCommit.
      */
     ProcArrayEndTransaction(MyProc, latestXid);
 
     /*
      * This is all post-commit cleanup.  Note that if an error is raised here,
      * it's too late to abort the transaction.  This should be just
      * noncritical resource releasing.
      *
      * The ordering of operations is not entirely random.  The idea is:
      * release resources visible to other backends (eg, files, buffer pins);
      * then release locks; then release backend-local resources. We want to
      * release locks at the point where any backend waiting for us will see
      * our transaction as being fully cleaned up.
      *
      * Resources that can be associated with individual queries are handled by
      * the ResourceOwner mechanism.  The other calls here are for backend-wide
      * state.
      */
 
     CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_COMMIT
                       : XACT_EVENT_COMMIT);
 
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_BEFORE_LOCKS,
                          true, true);
 
     /* Check we've released all buffer pins */
     AtEOXact_Buffers(true);
 
     /* Clean up the relation cache */
     AtEOXact_RelationCache(true);
 
     /*
      * Make catalog changes visible to all backends.  This has to happen after
      * relcache references are dropped (see comments for
      * AtEOXact_RelationCache), but before locks are released (if anyone is
      * waiting for lock on a relation we've modified, we want them to know
      * about the catalog change before they start using the relation).
      */
     AtEOXact_Inval(true);
 
     AtEOXact_MultiXact();
 
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_LOCKS,
                          true, true);
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_AFTER_LOCKS,
                          true, true);
 
     /*
      * Likewise, dropping of files deleted during the transaction is best done
      * after releasing relcache and buffer pins.  (This is not strictly
      * necessary during commit, since such pins should have been released
      * already, but this ordering is definitely critical during abort.)  Since
      * this may take many seconds, also delay until after releasing locks.
      * Other backends will observe the attendant catalog changes and not
      * attempt to access affected files.
      */
     smgrDoPendingDeletes(true);
 
     AtCommit_Notify();
     AtEOXact_GUC(true, 1);
     AtEOXact_SPI(true);
     AtEOXact_on_commit_actions(true);
     AtEOXact_Namespace(true, is_parallel_worker);
     AtEOXact_SMgr();
     AtEOXact_Files();
     AtEOXact_ComboCid();
     AtEOXact_HashTables(true);
     AtEOXact_PgStat(true);
     AtEOXact_Snapshot(true, false);
     AtEOXact_ApplyLauncher(true);
     pgstat_report_xact_timestamp(0);
 
     CurrentResourceOwner = NULL;
     ResourceOwnerDelete(TopTransactionResourceOwner);
     s->curTransactionOwner = NULL;
     CurTransactionResourceOwner = NULL;
     TopTransactionResourceOwner = NULL;
 
     AtCommit_Memory();
 
     s->transactionId = InvalidTransactionId;
     s->subTransactionId = InvalidSubTransactionId;
     s->nestingLevel = 0;
     s->gucNestLevel = 0;
     s->childXids = NULL;
     s->nChildXids = 0;
     s->maxChildXids = 0;
 
     XactTopTransactionId = InvalidTransactionId;
     nParallelCurrentXids = 0;
 
     /*
      * done with commit processing, set current transaction state back to
      * default
      */
     s->state = TRANS_DEFAULT;
 
     RESUME_INTERRUPTS();
 }

void CommitTransactionCommand ( void )

Definition at line 2744 of file xact.c.

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

Referenced by apply_handle_commit(), ApplyWorkerMain(), autoprewarm_database_main(), BeginInternalSubTransaction(), BootstrapModeMain(), cluster(), CommitTransactionCommand(), DefineIndex(), do_autovacuum(), finish_xact_command(), get_database_list(), get_subscription_list(), IdentifySystem(), index_drop(), initialize_worker_spi(), InitPostgres(), LogicalRepSyncTableStart(), maybe_reread_subscription(), movedb(), ParallelWorkerMain(), pg_attribute_noreturn(), process_syncing_tables_for_apply(), ProcessCatchupInterrupt(), ProcessCompletedNotifies(), ProcessIncomingNotify(), ReindexMultipleTables(), RemoveTempRelationsCallback(), vacuum(), and vacuum_rel().

 {
     TransactionState s = CurrentTransactionState;
 
     switch (s->blockState)
     {
             /*
              * These shouldn't happen.  TBLOCK_DEFAULT means the previous
              * StartTransactionCommand didn't set the STARTED state
              * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
              * by EndParallelWorkerTransaction(), not this function.
              */
         case TBLOCK_DEFAULT:
         case TBLOCK_PARALLEL_INPROGRESS:
             elog(FATAL, "CommitTransactionCommand: unexpected state %s",
                  BlockStateAsString(s->blockState));
             break;
 
             /*
              * If we aren't in a transaction block, just do our usual
              * transaction commit, and return to the idle state.
              */
         case TBLOCK_STARTED:
             CommitTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are completing a "BEGIN TRANSACTION" command, so we change
              * to the "transaction block in progress" state and return.  (We
              * assume the BEGIN did nothing to the database, so we need no
              * CommandCounterIncrement.)
              */
         case TBLOCK_BEGIN:
             s->blockState = TBLOCK_INPROGRESS;
             break;
 
             /*
              * This is the case when we have finished executing a command
              * someplace within a transaction block.  We increment the command
              * counter and return.
              */
         case TBLOCK_INPROGRESS:
         case TBLOCK_IMPLICIT_INPROGRESS:
         case TBLOCK_SUBINPROGRESS:
             CommandCounterIncrement();
             break;
 
             /*
              * We are completing a "COMMIT" command.  Do it and return to the
              * idle state.
              */
         case TBLOCK_END:
             CommitTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * Here we are in the middle of a transaction block but one of the
              * commands caused an abort so we do nothing but remain in the
              * abort state.  Eventually we will get a ROLLBACK command.
              */
         case TBLOCK_ABORT:
         case TBLOCK_SUBABORT:
             break;
 
             /*
              * Here we were in an aborted transaction block and we just got
              * the ROLLBACK command from the user, so clean up the
              * already-aborted transaction and return to the idle state.
              */
         case TBLOCK_ABORT_END:
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * Here we were in a perfectly good transaction block but the user
              * told us to ROLLBACK anyway.  We have to abort the transaction
              * and then clean up.
              */
         case TBLOCK_ABORT_PENDING:
             AbortTransaction();
             CleanupTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We are completing a "PREPARE TRANSACTION" command.  Do it and
              * return to the idle state.
              */
         case TBLOCK_PREPARE:
             PrepareTransaction();
             s->blockState = TBLOCK_DEFAULT;
             break;
 
             /*
              * We were just issued a SAVEPOINT inside a transaction block.
              * Start a subtransaction.  (DefineSavepoint already did
              * PushTransaction, so as to have someplace to put the SUBBEGIN
              * state.)
              */
         case TBLOCK_SUBBEGIN:
             StartSubTransaction();
             s->blockState = TBLOCK_SUBINPROGRESS;
             break;
 
             /*
              * We were issued a RELEASE command, so we end the current
              * subtransaction and return to the parent transaction. The parent
              * might be ended too, so repeat till we find an INPROGRESS
              * transaction or subtransaction.
              */
         case TBLOCK_SUBRELEASE:
             do
             {
                 CommitSubTransaction();
                 s = CurrentTransactionState;    /* changed by pop */
             } while (s->blockState == TBLOCK_SUBRELEASE);
 
             Assert(s->blockState == TBLOCK_INPROGRESS ||
                    s->blockState == TBLOCK_SUBINPROGRESS);
             break;
 
             /*
              * We were issued a COMMIT, so we end the current subtransaction
              * hierarchy and perform final commit. We do this by rolling up
              * any subtransactions into their parent, which leads to O(N^2)
              * operations with respect to resource owners - this isn't that
              * bad until we approach a thousands of savepoints but is
              * necessary for correctness should after triggers create new
              * resource owners.
              */
         case TBLOCK_SUBCOMMIT:
             do
             {
                 CommitSubTransaction();
                 s = CurrentTransactionState;    /* changed by pop */
             } while (s->blockState == TBLOCK_SUBCOMMIT);
             /* If we had a COMMIT command, finish off the main xact too */
             if (s->blockState == TBLOCK_END)
             {
                 Assert(s->parent == NULL);
                 CommitTransaction();
                 s->blockState = TBLOCK_DEFAULT;
             }
             else if (s->blockState == TBLOCK_PREPARE)
             {
                 Assert(s->parent == NULL);
                 PrepareTransaction();
                 s->blockState = TBLOCK_DEFAULT;
             }
             else
                 elog(ERROR, "CommitTransactionCommand: unexpected state %s",
                      BlockStateAsString(s->blockState));
             break;
 
             /*
              * The current already-failed subtransaction is ending due to a
              * ROLLBACK or ROLLBACK TO command, so pop it and recursively
              * examine the parent (which could be in any of several states).
              */
         case TBLOCK_SUBABORT_END:
             CleanupSubTransaction();
             CommitTransactionCommand();
             break;
 
             /*
              * As above, but it's not dead yet, so abort first.
              */
         case TBLOCK_SUBABORT_PENDING:
             AbortSubTransaction();
             CleanupSubTransaction();
             CommitTransactionCommand();
             break;
 
             /*
              * The current subtransaction is the target of a ROLLBACK TO
              * command.  Abort and pop it, then start a new subtransaction
              * with the same name.
              */
         case TBLOCK_SUBRESTART:
             {
                 char       *name;
                 int         savepointLevel;
 
                 /* save name and keep Cleanup from freeing it */
                 name = s->name;
                 s->name = NULL;
                 savepointLevel = s->savepointLevel;
 
                 AbortSubTransaction();
                 CleanupSubTransaction();
 
                 DefineSavepoint(NULL);
                 s = CurrentTransactionState;    /* changed by push */
                 s->name = name;
                 s->savepointLevel = savepointLevel;
 
                 /* This is the same as TBLOCK_SUBBEGIN case */
                 AssertState(s->blockState == TBLOCK_SUBBEGIN);
                 StartSubTransaction();
                 s->blockState = TBLOCK_SUBINPROGRESS;
             }
             break;
 
             /*
              * Same as above, but the subtransaction had already failed, so we
              * don't need AbortSubTransaction.
              */
         case TBLOCK_SUBABORT_RESTART:
             {
                 char       *name;
                 int         savepointLevel;
 
                 /* save name and keep Cleanup from freeing it */
                 name = s->name;
                 s->name = NULL;
                 savepointLevel = s->savepointLevel;
 
                 CleanupSubTransaction();
 
                 DefineSavepoint(NULL);
                 s = CurrentTransactionState;    /* changed by push */
                 s->name = name;
                 s->savepointLevel = savepointLevel;
 
                 /* This is the same as TBLOCK_SUBBEGIN case */
                 AssertState(s->blockState == TBLOCK_SUBBEGIN);
                 StartSubTransaction();
                 s->blockState = TBLOCK_SUBINPROGRESS;
             }
             break;
     }
 }

void DefineSavepoint ( char * name )

Definition at line 3826 of file xact.c.

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

Referenced by CommitTransactionCommand(), and standard_ProcessUtility().

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

void EndImplicitTransactionBlock ( void )

Definition at line 3804 of file xact.c.

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

Referenced by exec_simple_query().

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

void EndParallelWorkerTransaction ( void )

Definition at line 5084 of file xact.c.

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

Referenced by ParallelWorkerMain().

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

bool EndTransactionBlock ( void )

Definition at line 3533 of file xact.c.

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

Referenced by PrepareTransactionBlock(), and standard_ProcessUtility().

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

void EnterParallelMode ( void )

Definition at line 873 of file xact.c.

References Assert, CurrentTransactionState, and TransactionStateData::parallelModeLevel.

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

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

Size EstimateTransactionStateSpace ( void )

Definition at line 4960 of file xact.c.

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

Referenced by InitializeParallelDSM().

 {
     TransactionState s;
     Size        nxids = 6;      /* iso level, deferrable, top & current XID,
                                  * command counter, XID count */
 
     for (s = CurrentTransactionState; s != NULL; s = s->parent)
     {
         if (TransactionIdIsValid(s->transactionId))
             nxids = add_size(nxids, 1);
         nxids = add_size(nxids, s->nChildXids);
     }
 
     nxids = add_size(nxids, nParallelCurrentXids);
     return mul_size(nxids, sizeof(TransactionId));
 }

void ExitParallelMode ( void )

Definition at line 886 of file xact.c.

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

Referenced by ExecutePlan(), and ParallelWorkerMain().

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

void ForceSyncCommit ( void )

Definition at line 963 of file xact.c.

References forceSyncCommit.

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

 {
     forceSyncCommit = true;
 }

CommandId GetCurrentCommandId ( bool used )

Definition at line 680 of file xact.c.

References Assert, currentCommandId, currentCommandIdUsed, and TransactionStateData::parallelModeLevel.

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

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

TimestampTz GetCurrentStatementStartTimestamp ( void )

Definition at line 710 of file xact.c.

References stmtStartTimestamp.

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

 {
     return stmtStartTimestamp;
 }

SubTransactionId GetCurrentSubTransactionId ( void )

Definition at line 642 of file xact.c.

References CurrentTransactionState, and TransactionStateData::subTransactionId.

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

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

TransactionId GetCurrentTransactionId ( void )

Definition at line 418 of file xact.c.

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

Referenced by AlterEnum(), asyncQueueNotificationToEntry(), check_exclusion_or_unique_constraint(), ExecInsert(), funny_dup17(), heap_abort_speculative(), heap_delete(), heap_insert(), heap_lock_tuple(), heap_multi_insert(), heap_update(), LogAccessExclusiveLock(), LogAccessExclusiveLockPrepare(), logical_rewrite_log_mapping(), LogLogicalMessage(), PreCommit_Notify(), PrepareTransaction(), and ReorderBufferCommit().

 {
     TransactionState s = CurrentTransactionState;
 
     if (!TransactionIdIsValid(s->transactionId))
         AssignTransactionId(s);
     return s->transactionId;
 }

TransactionId GetCurrentTransactionIdIfAny ( void )

Definition at line 435 of file xact.c.

References TransactionStateData::transactionId.

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

 {
     return CurrentTransactionState->transactionId;
 }

int GetCurrentTransactionNestLevel ( void )

Definition at line 754 of file xact.c.

References CurrentTransactionState, and TransactionStateData::nestingLevel.

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

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

TimestampTz GetCurrentTransactionStartTimestamp ( void )

Definition at line 701 of file xact.c.

References xactStartTimestamp.

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

 {
     return xactStartTimestamp;
 }

TimestampTz GetCurrentTransactionStopTimestamp ( void )

Definition at line 722 of file xact.c.

References GetCurrentTimestamp(), and xactStopTimestamp.

Referenced by pgstat_report_stat().

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

TransactionId GetStableLatestTransactionId ( void )

Definition at line 462 of file xact.c.

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

Referenced by xid_age().

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

TransactionId GetTopTransactionId ( void )

Definition at line 390 of file xact.c.

References AssignTransactionId(), TransactionIdIsValid, and XactTopTransactionId.

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

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

TransactionId GetTopTransactionIdIfAny ( void )

Definition at line 405 of file xact.c.

References XactTopTransactionId.

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

 {
     return XactTopTransactionId;
 }

bool IsAbortedTransactionBlockState ( void )

Definition at line 371 of file xact.c.

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

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

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

bool IsInParallelMode ( void )

Definition at line 906 of file xact.c.

References TransactionStateData::parallelModeLevel.

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

 {
     return CurrentTransactionState->parallelModeLevel != 0;
 }

bool IsInTransactionChain ( bool isTopLevel )

Definition at line 3268 of file xact.c.

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

Referenced by vacuum().

 {
     /*
      * Return true on same conditions that would make PreventTransactionChain
      * error out
      */
     if (IsTransactionBlock())
         return true;
 
     if (IsSubTransaction())
         return true;
 
     if (!isTopLevel)
         return true;
 
     if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
         CurrentTransactionState->blockState != TBLOCK_STARTED)
         return true;
 
     return false;
 }

bool IsSubTransaction ( void )

Definition at line 4520 of file xact.c.

References CurrentTransactionState, and TransactionStateData::nestingLevel.

Referenced by AfterTriggerSetState(), check_transaction_deferrable(), check_transaction_read_only(), check_XactIsoLevel(), CheckTargetForConflictsIn(), CheckTransactionChain(), CreateReplicationSlot(), ExportSnapshot(), ImportSnapshot(), IsInTransactionChain(), PreventTransactionChain(), and RecoveryConflictInterrupt().

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

bool IsTransactionBlock ( void )

Definition at line 4447 of file xact.c.

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

Referenced by CheckTransactionChain(), CreateReplicationSlot(), exec_replication_command(), IsInTransactionChain(), and PreventTransactionChain().

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

bool IsTransactionOrTransactionBlock ( void )

Definition at line 4465 of file xact.c.

References TransactionStateData::blockState, CurrentTransactionState, and TBLOCK_DEFAULT.

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

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

bool IsTransactionState ( void )

Definition at line 351 of file xact.c.

References CurrentTransactionState, TransactionStateData::state, and TRANS_INPROGRESS.

Referenced by apply_handle_commit(), apply_handle_origin(), check_client_encoding(), check_default_tablespace(), check_role(), check_session_authorization(), check_temp_tablespaces(), check_transaction_read_only(), check_TSCurrentConfig(), check_XactIsoLevel(), CreateInitDecodingContext(), ensure_transaction(), LogLogicalMessage(), maybe_reread_subscription(), pg_attribute_noreturn(), pg_do_encoding_conversion(), PrepareClientEncoding(), PrepareTempTablespaces(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), RelationClearRelation(), RelationIdGetRelation(), RelationInitPhysicalAddr(), replorigin_create(), replorigin_drop(), SearchCatCacheInternal(), SetMultiXactIdLimit(), SetTransactionIdLimit(), SnapBuildClearExportedSnapshot(), and SocketBackend().

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

void MarkCurrentTransactionIdLoggedIfAny ( void )

Definition at line 446 of file xact.c.

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

Referenced by XLogInsertRecord().

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

static void PopTransaction ( void )

static

Definition at line 4926 of file xact.c.

References CurrentResourceOwner, CurrentTransactionState, CurTransactionContext, TransactionStateData::curTransactionContext, TransactionStateData::curTransactionOwner, CurTransactionResourceOwner, elog, FATAL, MemoryContextSwitchTo(), TransactionStateData::name, TransactionStateData::parent, pfree(), TransactionStateData::state, TRANS_DEFAULT, TransStateAsString(), and WARNING.

Referenced by CleanupSubTransaction(), and CommitSubTransaction().

 {
     TransactionState s = CurrentTransactionState;
 
     if (s->state != TRANS_DEFAULT)
         elog(WARNING, "PopTransaction while in %s state",
              TransStateAsString(s->state));
 
     if (s->parent == NULL)
         elog(FATAL, "PopTransaction with no parent");
 
     CurrentTransactionState = s->parent;
 
     /* Let's just make sure CurTransactionContext is good */
     CurTransactionContext = s->parent->curTransactionContext;
     MemoryContextSwitchTo(CurTransactionContext);
 
     /* Ditto for ResourceOwner links */
     CurTransactionResourceOwner = s->parent->curTransactionOwner;
     CurrentResourceOwner = s->parent->curTransactionOwner;
 
     /* Free the old child structure */
     if (s->name)
         pfree(s->name);
     pfree(s);
 }

static void PrepareTransaction ( void )

static

Definition at line 2169 of file xact.c.

Referenced by CommitTransactionCommand().

 {
     TransactionState s = CurrentTransactionState;
     TransactionId xid = GetCurrentTransactionId();
     GlobalTransaction gxact;
     TimestampTz prepared_at;
 
     Assert(!IsInParallelMode());
 
     ShowTransactionState("PrepareTransaction");
 
     /*
      * check the current transaction state
      */
     if (s->state != TRANS_INPROGRESS)
         elog(WARNING, "PrepareTransaction while in %s state",
              TransStateAsString(s->state));
     Assert(s->parent == NULL);
 
     /*
      * Do pre-commit processing that involves calling user-defined code, such
      * as triggers.  Since closing cursors could queue trigger actions,
      * triggers could open cursors, etc, we have to keep looping until there's
      * nothing left to do.
      */
     for (;;)
     {
         /*
          * Fire all currently pending deferred triggers.
          */
         AfterTriggerFireDeferred();
 
         /*
          * Close open portals (converting holdable ones into static portals).
          * If there weren't any, we are done ... otherwise loop back to check
          * if they queued deferred triggers.  Lather, rinse, repeat.
          */
         if (!PreCommit_Portals(true))
             break;
     }
 
     CallXactCallbacks(XACT_EVENT_PRE_PREPARE);
 
     /*
      * The remaining actions cannot call any user-defined code, so it's safe
      * to start shutting down within-transaction services.  But note that most
      * of this stuff could still throw an error, which would switch us into
      * the transaction-abort path.
      */
 
     /* Shut down the deferred-trigger manager */
     AfterTriggerEndXact(true);
 
     /*
      * Let ON COMMIT management do its thing (must happen after closing
      * cursors, to avoid dangling-reference problems)
      */
     PreCommit_on_commit_actions();
 
     /* close large objects before lower-level cleanup */
     AtEOXact_LargeObject(true);
 
     /*
      * Mark serializable transaction as complete for predicate locking
      * purposes.  This should be done as late as we can put it and still allow
      * errors to be raised for failure patterns found at commit.
      */
     PreCommit_CheckForSerializationFailure();
 
     /* NOTIFY will be handled below */
 
     /*
      * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
      * this transaction.  Having the prepared xact hold locks on another
      * backend's temp table seems a bad idea --- for instance it would prevent
      * the backend from exiting.  There are other problems too, such as how to
      * clean up the source backend's local buffers and ON COMMIT state if the
      * prepared xact includes a DROP of a temp table.
      *
      * We must check this after executing any ON COMMIT actions, because they
      * might still access a temp relation.
      *
      * XXX In principle this could be relaxed to allow some useful special
      * cases, such as a temp table created and dropped all within the
      * transaction.  That seems to require much more bookkeeping though.
      */
     if ((MyXactFlags & XACT_FLAGS_ACCESSEDTEMPREL))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot PREPARE a transaction that has operated on temporary tables")));
 
     /*
      * Likewise, don't allow PREPARE after pg_export_snapshot.  This could be
      * supported if we added cleanup logic to twophase.c, but for now it
      * doesn't seem worth the trouble.
      */
     if (XactHasExportedSnapshots())
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot PREPARE a transaction that has exported snapshots")));
 
     /*
      * Don't allow PREPARE but for transaction that has/might kill logical
      * replication workers.
      */
     if (XactManipulatesLogicalReplicationWorkers())
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot PREPARE a transaction that has manipulated logical replication workers")));
 
     /* Prevent cancel/die interrupt while cleaning up */
     HOLD_INTERRUPTS();
 
     /*
      * set the current transaction state information appropriately during
      * prepare processing
      */
     s->state = TRANS_PREPARE;
 
     prepared_at = GetCurrentTimestamp();
 
     /* Tell bufmgr and smgr to prepare for commit */
     BufmgrCommit();
 
     /*
      * Reserve the GID for this transaction. This could fail if the requested
      * GID is invalid or already in use.
      */
     gxact = MarkAsPreparing(xid, prepareGID, prepared_at,
                             GetUserId(), MyDatabaseId);
     prepareGID = NULL;
 
     /*
      * Collect data for the 2PC state file.  Note that in general, no actual
      * state change should happen in the called modules during this step,
      * since it's still possible to fail before commit, and in that case we
      * want transaction abort to be able to clean up.  (In particular, the
      * AtPrepare routines may error out if they find cases they cannot
      * handle.)  State cleanup should happen in the PostPrepare routines
      * below.  However, some modules can go ahead and clear state here because
      * they wouldn't do anything with it during abort anyway.
      *
      * Note: because the 2PC state file records will be replayed in the same
      * order they are made, the order of these calls has to match the order in
      * which we want things to happen during COMMIT PREPARED or ROLLBACK
      * PREPARED; in particular, pay attention to whether things should happen
      * before or after releasing the transaction's locks.
      */
     StartPrepare(gxact);
 
     AtPrepare_Notify();
     AtPrepare_Locks();
     AtPrepare_PredicateLocks();
     AtPrepare_PgStat();
     AtPrepare_MultiXact();
     AtPrepare_RelationMap();
 
     /*
      * Here is where we really truly prepare.
      *
      * We have to record transaction prepares even if we didn't make any
      * updates, because the transaction manager might get confused if we lose
      * a global transaction.
      */
     EndPrepare(gxact);
 
     /*
      * Now we clean up backend-internal state and release internal resources.
      */
 
     /* Reset XactLastRecEnd until the next transaction writes something */
     XactLastRecEnd = 0;
 
     /*
      * Let others know about no transaction in progress by me.  This has to be
      * done *after* the prepared transaction has been marked valid, else
      * someone may think it is unlocked and recyclable.
      */
     ProcArrayClearTransaction(MyProc);
 
     /*
      * In normal commit-processing, this is all non-critical post-transaction
      * cleanup.  When the transaction is prepared, however, it's important
      * that the locks and other per-backend resources are transferred to the
      * prepared transaction's PGPROC entry.  Note that if an error is raised
      * here, it's too late to abort the transaction. XXX: This probably should
      * be in a critical section, to force a PANIC if any of this fails, but
      * that cure could be worse than the disease.
      */
 
     CallXactCallbacks(XACT_EVENT_PREPARE);
 
     ResourceOwnerRelease(TopTransactionResourceOwner,
                          RESOURCE_RELEASE_BEFORE_LOCKS,
                          true, true);
 
     /* Check we've released all buffer pins */
     AtEOXact_Buffers(true);
 
     /* Clean up the relation cache */
     AtEOXact_RelationCache(true);
 
     

Enumerations
enum	TransState { TRANS_DEFAULT, TRANS_START, TRANS_INPROGRESS, TRANS_COMMIT, TRANS_ABORT, TRANS_PREPARE }

enum	TBlockState { TBLOCK_DEFAULT, TBLOCK_STARTED, TBLOCK_BEGIN, TBLOCK_INPROGRESS, TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_END, TBLOCK_ABORT, TBLOCK_ABORT_END, TBLOCK_ABORT_PENDING, TBLOCK_PREPARE, TBLOCK_SUBBEGIN, TBLOCK_SUBINPROGRESS, TBLOCK_SUBRELEASE, TBLOCK_SUBCOMMIT, TBLOCK_SUBABORT, TBLOCK_SUBABORT_END, TBLOCK_SUBABORT_PENDING, TBLOCK_SUBRESTART, TBLOCK_SUBABORT_RESTART }

Data Structures

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation