Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * xact.c
4 : * top level transaction system support routines
5 : *
6 : * See src/backend/access/transam/README for more information.
7 : *
8 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
9 : * Portions Copyright (c) 1994, Regents of the University of California
10 : *
11 : *
12 : * IDENTIFICATION
13 : * src/backend/access/transam/xact.c
14 : *
15 : *-------------------------------------------------------------------------
16 : */
17 :
18 : #include "postgres.h"
19 :
20 : #include <time.h>
21 : #include <unistd.h>
22 :
23 : #include "access/commit_ts.h"
24 : #include "access/multixact.h"
25 : #include "access/parallel.h"
26 : #include "access/subtrans.h"
27 : #include "access/transam.h"
28 : #include "access/twophase.h"
29 : #include "access/xact.h"
30 : #include "access/xlog.h"
31 : #include "access/xloginsert.h"
32 : #include "access/xlogrecovery.h"
33 : #include "access/xlogutils.h"
34 : #include "catalog/index.h"
35 : #include "catalog/namespace.h"
36 : #include "catalog/pg_enum.h"
37 : #include "catalog/storage.h"
38 : #include "commands/async.h"
39 : #include "commands/tablecmds.h"
40 : #include "commands/trigger.h"
41 : #include "common/pg_prng.h"
42 : #include "executor/spi.h"
43 : #include "libpq/be-fsstubs.h"
44 : #include "libpq/pqsignal.h"
45 : #include "miscadmin.h"
46 : #include "pg_trace.h"
47 : #include "pgstat.h"
48 : #include "replication/logical.h"
49 : #include "replication/logicallauncher.h"
50 : #include "replication/logicalworker.h"
51 : #include "replication/origin.h"
52 : #include "replication/snapbuild.h"
53 : #include "replication/syncrep.h"
54 : #include "storage/aio_subsys.h"
55 : #include "storage/condition_variable.h"
56 : #include "storage/fd.h"
57 : #include "storage/lmgr.h"
58 : #include "storage/md.h"
59 : #include "storage/predicate.h"
60 : #include "storage/proc.h"
61 : #include "storage/procarray.h"
62 : #include "storage/sinvaladt.h"
63 : #include "storage/smgr.h"
64 : #include "utils/builtins.h"
65 : #include "utils/combocid.h"
66 : #include "utils/guc.h"
67 : #include "utils/inval.h"
68 : #include "utils/memutils.h"
69 : #include "utils/relmapper.h"
70 : #include "utils/snapmgr.h"
71 : #include "utils/timeout.h"
72 : #include "utils/timestamp.h"
73 : #include "utils/typcache.h"
74 :
75 : /*
76 : * User-tweakable parameters
77 : */
78 : int DefaultXactIsoLevel = XACT_READ_COMMITTED;
79 : int XactIsoLevel = XACT_READ_COMMITTED;
80 :
81 : bool DefaultXactReadOnly = false;
82 : bool XactReadOnly;
83 :
84 : bool DefaultXactDeferrable = false;
85 : bool XactDeferrable;
86 :
87 : int synchronous_commit = SYNCHRONOUS_COMMIT_ON;
88 :
89 : /*
90 : * CheckXidAlive is a xid value pointing to a possibly ongoing (sub)
91 : * transaction. Currently, it is used in logical decoding. It's possible
92 : * that such transactions can get aborted while the decoding is ongoing in
93 : * which case we skip decoding that particular transaction. To ensure that we
94 : * check whether the CheckXidAlive is aborted after fetching the tuple from
95 : * system tables. We also ensure that during logical decoding we never
96 : * directly access the tableam or heap APIs because we are checking for the
97 : * concurrent aborts only in systable_* APIs.
98 : */
99 : TransactionId CheckXidAlive = InvalidTransactionId;
100 : bool bsysscan = false;
101 :
102 : /*
103 : * When running as a parallel worker, we place only a single
104 : * TransactionStateData on the parallel worker's state stack, and the XID
105 : * reflected there will be that of the *innermost* currently-active
106 : * subtransaction in the backend that initiated parallelism. However,
107 : * GetTopTransactionId() and TransactionIdIsCurrentTransactionId()
108 : * need to return the same answers in the parallel worker as they would have
109 : * in the user backend, so we need some additional bookkeeping.
110 : *
111 : * XactTopFullTransactionId stores the XID of our toplevel transaction, which
112 : * will be the same as TopTransactionStateData.fullTransactionId in an
113 : * ordinary backend; but in a parallel backend, which does not have the entire
114 : * transaction state, it will instead be copied from the backend that started
115 : * the parallel operation.
116 : *
117 : * nParallelCurrentXids will be 0 and ParallelCurrentXids NULL in an ordinary
118 : * backend, but in a parallel backend, nParallelCurrentXids will contain the
119 : * number of XIDs that need to be considered current, and ParallelCurrentXids
120 : * will contain the XIDs themselves. This includes all XIDs that were current
121 : * or sub-committed in the parent at the time the parallel operation began.
122 : * The XIDs are stored sorted in numerical order (not logical order) to make
123 : * lookups as fast as possible.
124 : */
125 : static FullTransactionId XactTopFullTransactionId = {InvalidTransactionId};
126 : static int nParallelCurrentXids = 0;
127 : static TransactionId *ParallelCurrentXids;
128 :
129 : /*
130 : * Miscellaneous flag bits to record events which occur on the top level
131 : * transaction. These flags are only persisted in MyXactFlags and are intended
132 : * so we remember to do certain things later on in the transaction. This is
133 : * globally accessible, so can be set from anywhere in the code that requires
134 : * recording flags.
135 : */
136 : int MyXactFlags;
137 :
138 : /*
139 : * transaction states - transaction state from server perspective
140 : */
141 : typedef enum TransState
142 : {
143 : TRANS_DEFAULT, /* idle */
144 : TRANS_START, /* transaction starting */
145 : TRANS_INPROGRESS, /* inside a valid transaction */
146 : TRANS_COMMIT, /* commit in progress */
147 : TRANS_ABORT, /* abort in progress */
148 : TRANS_PREPARE, /* prepare in progress */
149 : } TransState;
150 :
151 : /*
152 : * transaction block states - transaction state of client queries
153 : *
154 : * Note: the subtransaction states are used only for non-topmost
155 : * transactions; the others appear only in the topmost transaction.
156 : */
157 : typedef enum TBlockState
158 : {
159 : /* not-in-transaction-block states */
160 : TBLOCK_DEFAULT, /* idle */
161 : TBLOCK_STARTED, /* running single-query transaction */
162 :
163 : /* transaction block states */
164 : TBLOCK_BEGIN, /* starting transaction block */
165 : TBLOCK_INPROGRESS, /* live transaction */
166 : TBLOCK_IMPLICIT_INPROGRESS, /* live transaction after implicit BEGIN */
167 : TBLOCK_PARALLEL_INPROGRESS, /* live transaction inside parallel worker */
168 : TBLOCK_END, /* COMMIT received */
169 : TBLOCK_ABORT, /* failed xact, awaiting ROLLBACK */
170 : TBLOCK_ABORT_END, /* failed xact, ROLLBACK received */
171 : TBLOCK_ABORT_PENDING, /* live xact, ROLLBACK received */
172 : TBLOCK_PREPARE, /* live xact, PREPARE received */
173 :
174 : /* subtransaction states */
175 : TBLOCK_SUBBEGIN, /* starting a subtransaction */
176 : TBLOCK_SUBINPROGRESS, /* live subtransaction */
177 : TBLOCK_SUBRELEASE, /* RELEASE received */
178 : TBLOCK_SUBCOMMIT, /* COMMIT received while TBLOCK_SUBINPROGRESS */
179 : TBLOCK_SUBABORT, /* failed subxact, awaiting ROLLBACK */
180 : TBLOCK_SUBABORT_END, /* failed subxact, ROLLBACK received */
181 : TBLOCK_SUBABORT_PENDING, /* live subxact, ROLLBACK received */
182 : TBLOCK_SUBRESTART, /* live subxact, ROLLBACK TO received */
183 : TBLOCK_SUBABORT_RESTART, /* failed subxact, ROLLBACK TO received */
184 : } TBlockState;
185 :
186 : /*
187 : * transaction state structure
188 : *
189 : * Note: parallelModeLevel counts the number of unmatched EnterParallelMode
190 : * calls done at this transaction level. parallelChildXact is true if any
191 : * upper transaction level has nonzero parallelModeLevel.
192 : */
193 : typedef struct TransactionStateData
194 : {
195 : FullTransactionId fullTransactionId; /* my FullTransactionId */
196 : SubTransactionId subTransactionId; /* my subxact ID */
197 : char *name; /* savepoint name, if any */
198 : int savepointLevel; /* savepoint level */
199 : TransState state; /* low-level state */
200 : TBlockState blockState; /* high-level state */
201 : int nestingLevel; /* transaction nesting depth */
202 : int gucNestLevel; /* GUC context nesting depth */
203 : MemoryContext curTransactionContext; /* my xact-lifetime context */
204 : ResourceOwner curTransactionOwner; /* my query resources */
205 : MemoryContext priorContext; /* CurrentMemoryContext before xact started */
206 : TransactionId *childXids; /* subcommitted child XIDs, in XID order */
207 : int nChildXids; /* # of subcommitted child XIDs */
208 : int maxChildXids; /* allocated size of childXids[] */
209 : Oid prevUser; /* previous CurrentUserId setting */
210 : int prevSecContext; /* previous SecurityRestrictionContext */
211 : bool prevXactReadOnly; /* entry-time xact r/o state */
212 : bool startedInRecovery; /* did we start in recovery? */
213 : bool didLogXid; /* has xid been included in WAL record? */
214 : int parallelModeLevel; /* Enter/ExitParallelMode counter */
215 : bool parallelChildXact; /* is any parent transaction parallel? */
216 : bool chain; /* start a new block after this one */
217 : bool topXidLogged; /* for a subxact: is top-level XID logged? */
218 : struct TransactionStateData *parent; /* back link to parent */
219 : } TransactionStateData;
220 :
221 : typedef TransactionStateData *TransactionState;
222 :
223 : /*
224 : * Serialized representation used to transmit transaction state to parallel
225 : * workers through shared memory.
226 : */
227 : typedef struct SerializedTransactionState
228 : {
229 : int xactIsoLevel;
230 : bool xactDeferrable;
231 : FullTransactionId topFullTransactionId;
232 : FullTransactionId currentFullTransactionId;
233 : CommandId currentCommandId;
234 : int nParallelCurrentXids;
235 : TransactionId parallelCurrentXids[FLEXIBLE_ARRAY_MEMBER];
236 : } SerializedTransactionState;
237 :
238 : /* The size of SerializedTransactionState, not including the final array. */
239 : #define SerializedTransactionStateHeaderSize \
240 : offsetof(SerializedTransactionState, parallelCurrentXids)
241 :
242 : /*
243 : * CurrentTransactionState always points to the current transaction state
244 : * block. It will point to TopTransactionStateData when not in a
245 : * transaction at all, or when in a top-level transaction.
246 : */
247 : static TransactionStateData TopTransactionStateData = {
248 : .state = TRANS_DEFAULT,
249 : .blockState = TBLOCK_DEFAULT,
250 : .topXidLogged = false,
251 : };
252 :
253 : /*
254 : * unreportedXids holds XIDs of all subtransactions that have not yet been
255 : * reported in an XLOG_XACT_ASSIGNMENT record.
256 : */
257 : static int nUnreportedXids;
258 : static TransactionId unreportedXids[PGPROC_MAX_CACHED_SUBXIDS];
259 :
260 : static TransactionState CurrentTransactionState = &TopTransactionStateData;
261 :
262 : /*
263 : * The subtransaction ID and command ID assignment counters are global
264 : * to a whole transaction, so we do not keep them in the state stack.
265 : */
266 : static SubTransactionId currentSubTransactionId;
267 : static CommandId currentCommandId;
268 : static bool currentCommandIdUsed;
269 :
270 : /*
271 : * xactStartTimestamp is the value of transaction_timestamp().
272 : * stmtStartTimestamp is the value of statement_timestamp().
273 : * xactStopTimestamp is the time at which we log a commit / abort WAL record,
274 : * or if that was skipped, the time of the first subsequent
275 : * GetCurrentTransactionStopTimestamp() call.
276 : *
277 : * These do not change as we enter and exit subtransactions, so we don't
278 : * keep them inside the TransactionState stack.
279 : */
280 : static TimestampTz xactStartTimestamp;
281 : static TimestampTz stmtStartTimestamp;
282 : static TimestampTz xactStopTimestamp;
283 :
284 : /*
285 : * GID to be used for preparing the current transaction. This is also
286 : * global to a whole transaction, so we don't keep it in the state stack.
287 : */
288 : static char *prepareGID;
289 :
290 : /*
291 : * Some commands want to force synchronous commit.
292 : */
293 : static bool forceSyncCommit = false;
294 :
295 : /* Flag for logging statements in a transaction. */
296 : bool xact_is_sampled = false;
297 :
298 : /*
299 : * Private context for transaction-abort work --- we reserve space for this
300 : * at startup to ensure that AbortTransaction and AbortSubTransaction can work
301 : * when we've run out of memory.
302 : */
303 : static MemoryContext TransactionAbortContext = NULL;
304 :
305 : /*
306 : * List of add-on start- and end-of-xact callbacks
307 : */
308 : typedef struct XactCallbackItem
309 : {
310 : struct XactCallbackItem *next;
311 : XactCallback callback;
312 : void *arg;
313 : } XactCallbackItem;
314 :
315 : static XactCallbackItem *Xact_callbacks = NULL;
316 :
317 : /*
318 : * List of add-on start- and end-of-subxact callbacks
319 : */
320 : typedef struct SubXactCallbackItem
321 : {
322 : struct SubXactCallbackItem *next;
323 : SubXactCallback callback;
324 : void *arg;
325 : } SubXactCallbackItem;
326 :
327 : static SubXactCallbackItem *SubXact_callbacks = NULL;
328 :
329 :
330 : /* local function prototypes */
331 : static void AssignTransactionId(TransactionState s);
332 : static void AbortTransaction(void);
333 : static void AtAbort_Memory(void);
334 : static void AtCleanup_Memory(void);
335 : static void AtAbort_ResourceOwner(void);
336 : static void AtCCI_LocalCache(void);
337 : static void AtCommit_Memory(void);
338 : static void AtStart_Cache(void);
339 : static void AtStart_Memory(void);
340 : static void AtStart_ResourceOwner(void);
341 : static void CallXactCallbacks(XactEvent event);
342 : static void CallSubXactCallbacks(SubXactEvent event,
343 : SubTransactionId mySubid,
344 : SubTransactionId parentSubid);
345 : static void CleanupTransaction(void);
346 : static void CheckTransactionBlock(bool isTopLevel, bool throwError,
347 : const char *stmtType);
348 : static void CommitTransaction(void);
349 : static TransactionId RecordTransactionAbort(bool isSubXact);
350 : static void StartTransaction(void);
351 :
352 : static bool CommitTransactionCommandInternal(void);
353 : static bool AbortCurrentTransactionInternal(void);
354 :
355 : static void StartSubTransaction(void);
356 : static void CommitSubTransaction(void);
357 : static void AbortSubTransaction(void);
358 : static void CleanupSubTransaction(void);
359 : static void PushTransaction(void);
360 : static void PopTransaction(void);
361 :
362 : static void AtSubAbort_Memory(void);
363 : static void AtSubCleanup_Memory(void);
364 : static void AtSubAbort_ResourceOwner(void);
365 : static void AtSubCommit_Memory(void);
366 : static void AtSubStart_Memory(void);
367 : static void AtSubStart_ResourceOwner(void);
368 :
369 : static void ShowTransactionState(const char *str);
370 : static void ShowTransactionStateRec(const char *str, TransactionState s);
371 : static const char *BlockStateAsString(TBlockState blockState);
372 : static const char *TransStateAsString(TransState state);
373 :
374 :
375 : /* ----------------------------------------------------------------
376 : * transaction state accessors
377 : * ----------------------------------------------------------------
378 : */
379 :
380 : /*
381 : * IsTransactionState
382 : *
383 : * This returns true if we are inside a valid transaction; that is,
384 : * it is safe to initiate database access, take heavyweight locks, etc.
385 : */
386 : bool
387 2107190 : IsTransactionState(void)
388 : {
389 2107190 : TransactionState s = CurrentTransactionState;
390 :
391 : /*
392 : * TRANS_DEFAULT and TRANS_ABORT are obviously unsafe states. However, we
393 : * also reject the startup/shutdown states TRANS_START, TRANS_COMMIT,
394 : * TRANS_PREPARE since it might be too soon or too late within those
395 : * transition states to do anything interesting. Hence, the only "valid"
396 : * state is TRANS_INPROGRESS.
397 : */
398 2107190 : return (s->state == TRANS_INPROGRESS);
399 : }
400 :
401 : /*
402 : * IsAbortedTransactionBlockState
403 : *
404 : * This returns true if we are within an aborted transaction block.
405 : */
406 : bool
407 1541820 : IsAbortedTransactionBlockState(void)
408 : {
409 1541820 : TransactionState s = CurrentTransactionState;
410 :
411 1541820 : if (s->blockState == TBLOCK_ABORT ||
412 1538842 : s->blockState == TBLOCK_SUBABORT)
413 3562 : return true;
414 :
415 1538258 : return false;
416 : }
417 :
418 :
419 : /*
420 : * GetTopTransactionId
421 : *
422 : * This will return the XID of the main transaction, assigning one if
423 : * it's not yet set. Be careful to call this only inside a valid xact.
424 : */
425 : TransactionId
426 59336 : GetTopTransactionId(void)
427 : {
428 59336 : if (!FullTransactionIdIsValid(XactTopFullTransactionId))
429 1222 : AssignTransactionId(&TopTransactionStateData);
430 59336 : return XidFromFullTransactionId(XactTopFullTransactionId);
431 : }
432 :
433 : /*
434 : * GetTopTransactionIdIfAny
435 : *
436 : * This will return the XID of the main transaction, if one is assigned.
437 : * It will return InvalidTransactionId if we are not currently inside a
438 : * transaction, or inside a transaction that hasn't yet been assigned an XID.
439 : */
440 : TransactionId
441 87658852 : GetTopTransactionIdIfAny(void)
442 : {
443 87658852 : return XidFromFullTransactionId(XactTopFullTransactionId);
444 : }
445 :
446 : /*
447 : * GetCurrentTransactionId
448 : *
449 : * This will return the XID of the current transaction (main or sub
450 : * transaction), assigning one if it's not yet set. Be careful to call this
451 : * only inside a valid xact.
452 : */
453 : TransactionId
454 21589714 : GetCurrentTransactionId(void)
455 : {
456 21589714 : TransactionState s = CurrentTransactionState;
457 :
458 21589714 : if (!FullTransactionIdIsValid(s->fullTransactionId))
459 265392 : AssignTransactionId(s);
460 21589700 : return XidFromFullTransactionId(s->fullTransactionId);
461 : }
462 :
463 : /*
464 : * GetCurrentTransactionIdIfAny
465 : *
466 : * This will return the XID of the current sub xact, if one is assigned.
467 : * It will return InvalidTransactionId if we are not currently inside a
468 : * transaction, or inside a transaction that hasn't been assigned an XID yet.
469 : */
470 : TransactionId
471 29316682 : GetCurrentTransactionIdIfAny(void)
472 : {
473 29316682 : return XidFromFullTransactionId(CurrentTransactionState->fullTransactionId);
474 : }
475 :
476 : /*
477 : * GetTopFullTransactionId
478 : *
479 : * This will return the FullTransactionId of the main transaction, assigning
480 : * one if it's not yet set. Be careful to call this only inside a valid xact.
481 : */
482 : FullTransactionId
483 5732 : GetTopFullTransactionId(void)
484 : {
485 5732 : if (!FullTransactionIdIsValid(XactTopFullTransactionId))
486 4166 : AssignTransactionId(&TopTransactionStateData);
487 5732 : return XactTopFullTransactionId;
488 : }
489 :
490 : /*
491 : * GetTopFullTransactionIdIfAny
492 : *
493 : * This will return the FullTransactionId of the main transaction, if one is
494 : * assigned. It will return InvalidFullTransactionId if we are not currently
495 : * inside a transaction, or inside a transaction that hasn't yet been assigned
496 : * one.
497 : */
498 : FullTransactionId
499 24 : GetTopFullTransactionIdIfAny(void)
500 : {
501 24 : return XactTopFullTransactionId;
502 : }
503 :
504 : /*
505 : * GetCurrentFullTransactionId
506 : *
507 : * This will return the FullTransactionId of the current transaction (main or
508 : * sub transaction), assigning one if it's not yet set. Be careful to call
509 : * this only inside a valid xact.
510 : */
511 : FullTransactionId
512 668 : GetCurrentFullTransactionId(void)
513 : {
514 668 : TransactionState s = CurrentTransactionState;
515 :
516 668 : if (!FullTransactionIdIsValid(s->fullTransactionId))
517 34 : AssignTransactionId(s);
518 668 : return s->fullTransactionId;
519 : }
520 :
521 : /*
522 : * GetCurrentFullTransactionIdIfAny
523 : *
524 : * This will return the FullTransactionId of the current sub xact, if one is
525 : * assigned. It will return InvalidFullTransactionId if we are not currently
526 : * inside a transaction, or inside a transaction that hasn't been assigned one
527 : * yet.
528 : */
529 : FullTransactionId
530 0 : GetCurrentFullTransactionIdIfAny(void)
531 : {
532 0 : return CurrentTransactionState->fullTransactionId;
533 : }
534 :
535 : /*
536 : * MarkCurrentTransactionIdLoggedIfAny
537 : *
538 : * Remember that the current xid - if it is assigned - now has been wal logged.
539 : */
540 : void
541 29238612 : MarkCurrentTransactionIdLoggedIfAny(void)
542 : {
543 29238612 : if (FullTransactionIdIsValid(CurrentTransactionState->fullTransactionId))
544 28686978 : CurrentTransactionState->didLogXid = true;
545 29238612 : }
546 :
547 : /*
548 : * IsSubxactTopXidLogPending
549 : *
550 : * This is used to decide whether we need to WAL log the top-level XID for
551 : * operation in a subtransaction. We require that for logical decoding, see
552 : * LogicalDecodingProcessRecord.
553 : *
554 : * This returns true if wal_level >= logical and we are inside a valid
555 : * subtransaction, for which the assignment was not yet written to any WAL
556 : * record.
557 : */
558 : bool
559 29253636 : IsSubxactTopXidLogPending(void)
560 : {
561 : /* check whether it is already logged */
562 29253636 : if (CurrentTransactionState->topXidLogged)
563 204248 : return false;
564 :
565 : /* wal_level has to be logical */
566 29049388 : if (!XLogLogicalInfoActive())
567 27983264 : return false;
568 :
569 : /* we need to be in a transaction state */
570 1066124 : if (!IsTransactionState())
571 7534 : return false;
572 :
573 : /* it has to be a subtransaction */
574 1058590 : if (!IsSubTransaction())
575 1058134 : return false;
576 :
577 : /* the subtransaction has to have a XID assigned */
578 456 : if (!TransactionIdIsValid(GetCurrentTransactionIdIfAny()))
579 14 : return false;
580 :
581 442 : return true;
582 : }
583 :
584 : /*
585 : * MarkSubxactTopXidLogged
586 : *
587 : * Remember that the top transaction id for the current subtransaction is WAL
588 : * logged now.
589 : */
590 : void
591 438 : MarkSubxactTopXidLogged(void)
592 : {
593 : Assert(IsSubxactTopXidLogPending());
594 :
595 438 : CurrentTransactionState->topXidLogged = true;
596 438 : }
597 :
598 : /*
599 : * GetStableLatestTransactionId
600 : *
601 : * Get the transaction's XID if it has one, else read the next-to-be-assigned
602 : * XID. Once we have a value, return that same value for the remainder of the
603 : * current transaction. This is meant to provide the reference point for the
604 : * age(xid) function, but might be useful for other maintenance tasks as well.
605 : */
606 : TransactionId
607 308 : GetStableLatestTransactionId(void)
608 : {
609 : static LocalTransactionId lxid = InvalidLocalTransactionId;
610 : static TransactionId stablexid = InvalidTransactionId;
611 :
612 308 : if (lxid != MyProc->vxid.lxid)
613 : {
614 32 : lxid = MyProc->vxid.lxid;
615 32 : stablexid = GetTopTransactionIdIfAny();
616 32 : if (!TransactionIdIsValid(stablexid))
617 32 : stablexid = ReadNextTransactionId();
618 : }
619 :
620 : Assert(TransactionIdIsValid(stablexid));
621 :
622 308 : return stablexid;
623 : }
624 :
625 : /*
626 : * AssignTransactionId
627 : *
628 : * Assigns a new permanent FullTransactionId to the given TransactionState.
629 : * We do not assign XIDs to transactions until/unless this is called.
630 : * Also, any parent TransactionStates that don't yet have XIDs are assigned
631 : * one; this maintains the invariant that a child transaction has an XID
632 : * following its parent's.
633 : */
634 : static void
635 273122 : AssignTransactionId(TransactionState s)
636 : {
637 273122 : bool isSubXact = (s->parent != NULL);
638 : ResourceOwner currentOwner;
639 273122 : bool log_unknown_top = false;
640 :
641 : /* Assert that caller didn't screw up */
642 : Assert(!FullTransactionIdIsValid(s->fullTransactionId));
643 : Assert(s->state == TRANS_INPROGRESS);
644 :
645 : /*
646 : * Workers synchronize transaction state at the beginning of each parallel
647 : * operation, so we can't account for new XIDs at this point.
648 : */
649 273122 : if (IsInParallelMode() || IsParallelWorker())
650 0 : ereport(ERROR,
651 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
652 : errmsg("cannot assign transaction IDs during a parallel operation")));
653 :
654 : /*
655 : * Ensure parent(s) have XIDs, so that a child always has an XID later
656 : * than its parent. Mustn't recurse here, or we might get a stack
657 : * overflow if we're at the bottom of a huge stack of subtransactions none
658 : * of which have XIDs yet.
659 : */
660 273122 : if (isSubXact && !FullTransactionIdIsValid(s->parent->fullTransactionId))
661 : {
662 1170 : TransactionState p = s->parent;
663 : TransactionState *parents;
664 1170 : size_t parentOffset = 0;
665 :
666 1170 : parents = palloc(sizeof(TransactionState) * s->nestingLevel);
667 3478 : while (p != NULL && !FullTransactionIdIsValid(p->fullTransactionId))
668 : {
669 2308 : parents[parentOffset++] = p;
670 2308 : p = p->parent;
671 : }
672 :
673 : /*
674 : * This is technically a recursive call, but the recursion will never
675 : * be more than one layer deep.
676 : */
677 3478 : while (parentOffset != 0)
678 2308 : AssignTransactionId(parents[--parentOffset]);
679 :
680 1170 : pfree(parents);
681 : }
682 :
683 : /*
684 : * When wal_level=logical, guarantee that a subtransaction's xid can only
685 : * be seen in the WAL stream if its toplevel xid has been logged before.
686 : * If necessary we log an xact_assignment record with fewer than
687 : * PGPROC_MAX_CACHED_SUBXIDS. Note that it is fine if didLogXid isn't set
688 : * for a transaction even though it appears in a WAL record, we just might
689 : * superfluously log something. That can happen when an xid is included
690 : * somewhere inside a wal record, but not in XLogRecord->xl_xid, like in
691 : * xl_standby_locks.
692 : */
693 273122 : if (isSubXact && XLogLogicalInfoActive() &&
694 600 : !TopTransactionStateData.didLogXid)
695 48 : log_unknown_top = true;
696 :
697 : /*
698 : * Generate a new FullTransactionId and record its xid in PGPROC and
699 : * pg_subtrans.
700 : *
701 : * NB: we must make the subtrans entry BEFORE the Xid appears anywhere in
702 : * shared storage other than PGPROC; because if there's no room for it in
703 : * PGPROC, the subtrans entry is needed to ensure that other backends see
704 : * the Xid as "running". See GetNewTransactionId.
705 : */
706 273122 : s->fullTransactionId = GetNewTransactionId(isSubXact);
707 273108 : if (!isSubXact)
708 264444 : XactTopFullTransactionId = s->fullTransactionId;
709 :
710 273108 : if (isSubXact)
711 8664 : SubTransSetParent(XidFromFullTransactionId(s->fullTransactionId),
712 8664 : XidFromFullTransactionId(s->parent->fullTransactionId));
713 :
714 : /*
715 : * If it's a top-level transaction, the predicate locking system needs to
716 : * be told about it too.
717 : */
718 273108 : if (!isSubXact)
719 264444 : RegisterPredicateLockingXid(XidFromFullTransactionId(s->fullTransactionId));
720 :
721 : /*
722 : * Acquire lock on the transaction XID. (We assume this cannot block.) We
723 : * have to ensure that the lock is assigned to the transaction's own
724 : * ResourceOwner.
725 : */
726 273108 : currentOwner = CurrentResourceOwner;
727 273108 : CurrentResourceOwner = s->curTransactionOwner;
728 :
729 273108 : XactLockTableInsert(XidFromFullTransactionId(s->fullTransactionId));
730 :
731 273108 : CurrentResourceOwner = currentOwner;
732 :
733 : /*
734 : * Every PGPROC_MAX_CACHED_SUBXIDS assigned transaction ids within each
735 : * top-level transaction we issue a WAL record for the assignment. We
736 : * include the top-level xid and all the subxids that have not yet been
737 : * reported using XLOG_XACT_ASSIGNMENT records.
738 : *
739 : * This is required to limit the amount of shared memory required in a hot
740 : * standby server to keep track of in-progress XIDs. See notes for
741 : * RecordKnownAssignedTransactionIds().
742 : *
743 : * We don't keep track of the immediate parent of each subxid, only the
744 : * top-level transaction that each subxact belongs to. This is correct in
745 : * recovery only because aborted subtransactions are separately WAL
746 : * logged.
747 : *
748 : * This is correct even for the case where several levels above us didn't
749 : * have an xid assigned as we recursed up to them beforehand.
750 : */
751 273108 : if (isSubXact && XLogStandbyInfoActive())
752 : {
753 7656 : unreportedXids[nUnreportedXids] = XidFromFullTransactionId(s->fullTransactionId);
754 7656 : nUnreportedXids++;
755 :
756 : /*
757 : * ensure this test matches similar one in
758 : * RecoverPreparedTransactions()
759 : */
760 7656 : if (nUnreportedXids >= PGPROC_MAX_CACHED_SUBXIDS ||
761 : log_unknown_top)
762 : {
763 : xl_xact_assignment xlrec;
764 :
765 : /*
766 : * xtop is always set by now because we recurse up transaction
767 : * stack to the highest unassigned xid and then come back down
768 : */
769 132 : xlrec.xtop = GetTopTransactionId();
770 : Assert(TransactionIdIsValid(xlrec.xtop));
771 132 : xlrec.nsubxacts = nUnreportedXids;
772 :
773 132 : XLogBeginInsert();
774 132 : XLogRegisterData(&xlrec, MinSizeOfXactAssignment);
775 132 : XLogRegisterData(unreportedXids,
776 : nUnreportedXids * sizeof(TransactionId));
777 :
778 132 : (void) XLogInsert(RM_XACT_ID, XLOG_XACT_ASSIGNMENT);
779 :
780 132 : nUnreportedXids = 0;
781 : /* mark top, not current xact as having been logged */
782 132 : TopTransactionStateData.didLogXid = true;
783 : }
784 : }
785 273108 : }
786 :
787 : /*
788 : * GetCurrentSubTransactionId
789 : */
790 : SubTransactionId
791 17914898 : GetCurrentSubTransactionId(void)
792 : {
793 17914898 : TransactionState s = CurrentTransactionState;
794 :
795 17914898 : return s->subTransactionId;
796 : }
797 :
798 : /*
799 : * SubTransactionIsActive
800 : *
801 : * Test if the specified subxact ID is still active. Note caller is
802 : * responsible for checking whether this ID is relevant to the current xact.
803 : */
804 : bool
805 0 : SubTransactionIsActive(SubTransactionId subxid)
806 : {
807 : TransactionState s;
808 :
809 0 : for (s = CurrentTransactionState; s != NULL; s = s->parent)
810 : {
811 0 : if (s->state == TRANS_ABORT)
812 0 : continue;
813 0 : if (s->subTransactionId == subxid)
814 0 : return true;
815 : }
816 0 : return false;
817 : }
818 :
819 :
820 : /*
821 : * GetCurrentCommandId
822 : *
823 : * "used" must be true if the caller intends to use the command ID to mark
824 : * inserted/updated/deleted tuples. false means the ID is being fetched
825 : * for read-only purposes (ie, as a snapshot validity cutoff). See
826 : * CommandCounterIncrement() for discussion.
827 : */
828 : CommandId
829 11895678 : GetCurrentCommandId(bool used)
830 : {
831 : /* this is global to a transaction, not subtransaction-local */
832 11895678 : if (used)
833 : {
834 : /*
835 : * Forbid setting currentCommandIdUsed in a parallel worker, because
836 : * we have no provision for communicating this back to the leader. We
837 : * could relax this restriction when currentCommandIdUsed was already
838 : * true at the start of the parallel operation.
839 : */
840 6990822 : if (IsParallelWorker())
841 0 : ereport(ERROR,
842 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
843 : errmsg("cannot modify data in a parallel worker")));
844 :
845 6990822 : currentCommandIdUsed = true;
846 : }
847 11895678 : return currentCommandId;
848 : }
849 :
850 : /*
851 : * SetParallelStartTimestamps
852 : *
853 : * In a parallel worker, we should inherit the parent transaction's
854 : * timestamps rather than setting our own. The parallel worker
855 : * infrastructure must call this to provide those values before
856 : * calling StartTransaction() or SetCurrentStatementStartTimestamp().
857 : */
858 : void
859 2746 : SetParallelStartTimestamps(TimestampTz xact_ts, TimestampTz stmt_ts)
860 : {
861 : Assert(IsParallelWorker());
862 2746 : xactStartTimestamp = xact_ts;
863 2746 : stmtStartTimestamp = stmt_ts;
864 2746 : }
865 :
866 : /*
867 : * GetCurrentTransactionStartTimestamp
868 : */
869 : TimestampTz
870 86614 : GetCurrentTransactionStartTimestamp(void)
871 : {
872 86614 : return xactStartTimestamp;
873 : }
874 :
875 : /*
876 : * GetCurrentStatementStartTimestamp
877 : */
878 : TimestampTz
879 2452556 : GetCurrentStatementStartTimestamp(void)
880 : {
881 2452556 : return stmtStartTimestamp;
882 : }
883 :
884 : /*
885 : * GetCurrentTransactionStopTimestamp
886 : *
887 : * If the transaction stop time hasn't already been set, which can happen if
888 : * we decided we don't need to log an XLOG record, set xactStopTimestamp.
889 : */
890 : TimestampTz
891 2062910 : GetCurrentTransactionStopTimestamp(void)
892 : {
893 2062910 : TransactionState s PG_USED_FOR_ASSERTS_ONLY = CurrentTransactionState;
894 :
895 : /* should only be called after commit / abort processing */
896 : Assert(s->state == TRANS_DEFAULT ||
897 : s->state == TRANS_COMMIT ||
898 : s->state == TRANS_ABORT ||
899 : s->state == TRANS_PREPARE);
900 :
901 2062910 : if (xactStopTimestamp == 0)
902 588444 : xactStopTimestamp = GetCurrentTimestamp();
903 :
904 2062910 : return xactStopTimestamp;
905 : }
906 :
907 : /*
908 : * SetCurrentStatementStartTimestamp
909 : *
910 : * In a parallel worker, this should already have been provided by a call
911 : * to SetParallelStartTimestamps().
912 : */
913 : void
914 1289102 : SetCurrentStatementStartTimestamp(void)
915 : {
916 1289102 : if (!IsParallelWorker())
917 1286356 : stmtStartTimestamp = GetCurrentTimestamp();
918 : else
919 : Assert(stmtStartTimestamp != 0);
920 1289102 : }
921 :
922 : /*
923 : * GetCurrentTransactionNestLevel
924 : *
925 : * Note: this will return zero when not inside any transaction, one when
926 : * inside a top-level transaction, etc.
927 : */
928 : int
929 35524586 : GetCurrentTransactionNestLevel(void)
930 : {
931 35524586 : TransactionState s = CurrentTransactionState;
932 :
933 35524586 : return s->nestingLevel;
934 : }
935 :
936 :
937 : /*
938 : * TransactionIdIsCurrentTransactionId
939 : */
940 : bool
941 87707420 : TransactionIdIsCurrentTransactionId(TransactionId xid)
942 : {
943 : TransactionState s;
944 :
945 : /*
946 : * We always say that BootstrapTransactionId is "not my transaction ID"
947 : * even when it is (ie, during bootstrap). Along with the fact that
948 : * transam.c always treats BootstrapTransactionId as already committed,
949 : * this causes the heapam_visibility.c routines to see all tuples as
950 : * committed, which is what we need during bootstrap. (Bootstrap mode
951 : * only inserts tuples, it never updates or deletes them, so all tuples
952 : * can be presumed good immediately.)
953 : *
954 : * Likewise, InvalidTransactionId and FrozenTransactionId are certainly
955 : * not my transaction ID, so we can just return "false" immediately for
956 : * any non-normal XID.
957 : */
958 87707420 : if (!TransactionIdIsNormal(xid))
959 1303606 : return false;
960 :
961 86403814 : if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
962 56473104 : return true;
963 :
964 : /*
965 : * In parallel workers, the XIDs we must consider as current are stored in
966 : * ParallelCurrentXids rather than the transaction-state stack. Note that
967 : * the XIDs in this array are sorted numerically rather than according to
968 : * transactionIdPrecedes order.
969 : */
970 29930710 : if (nParallelCurrentXids > 0)
971 : {
972 : int low,
973 : high;
974 :
975 3784276 : low = 0;
976 3784276 : high = nParallelCurrentXids - 1;
977 14779022 : while (low <= high)
978 : {
979 : int middle;
980 : TransactionId probe;
981 :
982 14600068 : middle = low + (high - low) / 2;
983 14600068 : probe = ParallelCurrentXids[middle];
984 14600068 : if (probe == xid)
985 3605322 : return true;
986 10994746 : else if (probe < xid)
987 10815800 : low = middle + 1;
988 : else
989 178946 : high = middle - 1;
990 : }
991 178954 : return false;
992 : }
993 :
994 : /*
995 : * We will return true for the Xid of the current subtransaction, any of
996 : * its subcommitted children, any of its parents, or any of their
997 : * previously subcommitted children. However, a transaction being aborted
998 : * is no longer "current", even though it may still have an entry on the
999 : * state stack.
1000 : */
1001 52344632 : for (s = CurrentTransactionState; s != NULL; s = s->parent)
1002 : {
1003 : int low,
1004 : high;
1005 :
1006 26270188 : if (s->state == TRANS_ABORT)
1007 0 : continue;
1008 26270188 : if (!FullTransactionIdIsValid(s->fullTransactionId))
1009 19096994 : continue; /* it can't have any child XIDs either */
1010 7173194 : if (TransactionIdEquals(xid, XidFromFullTransactionId(s->fullTransactionId)))
1011 68912 : return true;
1012 : /* As the childXids array is ordered, we can use binary search */
1013 7104282 : low = 0;
1014 7104282 : high = s->nChildXids - 1;
1015 7106026 : while (low <= high)
1016 : {
1017 : int middle;
1018 : TransactionId probe;
1019 :
1020 4822 : middle = low + (high - low) / 2;
1021 4822 : probe = s->childXids[middle];
1022 4822 : if (TransactionIdEquals(probe, xid))
1023 3078 : return true;
1024 1744 : else if (TransactionIdPrecedes(probe, xid))
1025 1606 : low = middle + 1;
1026 : else
1027 138 : high = middle - 1;
1028 : }
1029 : }
1030 :
1031 26074444 : return false;
1032 : }
1033 :
1034 : /*
1035 : * TransactionStartedDuringRecovery
1036 : *
1037 : * Returns true if the current transaction started while recovery was still
1038 : * in progress. Recovery might have ended since so RecoveryInProgress() might
1039 : * return false already.
1040 : */
1041 : bool
1042 15536556 : TransactionStartedDuringRecovery(void)
1043 : {
1044 15536556 : return CurrentTransactionState->startedInRecovery;
1045 : }
1046 :
1047 : /*
1048 : * EnterParallelMode
1049 : */
1050 : void
1051 6366 : EnterParallelMode(void)
1052 : {
1053 6366 : TransactionState s = CurrentTransactionState;
1054 :
1055 : Assert(s->parallelModeLevel >= 0);
1056 :
1057 6366 : ++s->parallelModeLevel;
1058 6366 : }
1059 :
1060 : /*
1061 : * ExitParallelMode
1062 : */
1063 : void
1064 3608 : ExitParallelMode(void)
1065 : {
1066 3608 : TransactionState s = CurrentTransactionState;
1067 :
1068 : Assert(s->parallelModeLevel > 0);
1069 : Assert(s->parallelModeLevel > 1 || s->parallelChildXact ||
1070 : !ParallelContextActive());
1071 :
1072 3608 : --s->parallelModeLevel;
1073 3608 : }
1074 :
1075 : /*
1076 : * IsInParallelMode
1077 : *
1078 : * Are we in a parallel operation, as either the leader or a worker? Check
1079 : * this to prohibit operations that change backend-local state expected to
1080 : * match across all workers. Mere caches usually don't require such a
1081 : * restriction. State modified in a strict push/pop fashion, such as the
1082 : * active snapshot stack, is often fine.
1083 : *
1084 : * We say we are in parallel mode if we are in a subxact of a transaction
1085 : * that's initiated a parallel operation; for most purposes that context
1086 : * has all the same restrictions.
1087 : */
1088 : bool
1089 57828252 : IsInParallelMode(void)
1090 : {
1091 57828252 : TransactionState s = CurrentTransactionState;
1092 :
1093 57828252 : return s->parallelModeLevel != 0 || s->parallelChildXact;
1094 : }
1095 :
1096 : /*
1097 : * CommandCounterIncrement
1098 : */
1099 : void
1100 2192604 : CommandCounterIncrement(void)
1101 : {
1102 : /*
1103 : * If the current value of the command counter hasn't been "used" to mark
1104 : * tuples, we need not increment it, since there's no need to distinguish
1105 : * a read-only command from others. This helps postpone command counter
1106 : * overflow, and keeps no-op CommandCounterIncrement operations cheap.
1107 : */
1108 2192604 : if (currentCommandIdUsed)
1109 : {
1110 : /*
1111 : * Workers synchronize transaction state at the beginning of each
1112 : * parallel operation, so we can't account for new commands after that
1113 : * point.
1114 : */
1115 1150314 : if (IsInParallelMode() || IsParallelWorker())
1116 0 : ereport(ERROR,
1117 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
1118 : errmsg("cannot start commands during a parallel operation")));
1119 :
1120 1150314 : currentCommandId += 1;
1121 1150314 : if (currentCommandId == InvalidCommandId)
1122 : {
1123 0 : currentCommandId -= 1;
1124 0 : ereport(ERROR,
1125 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1126 : errmsg("cannot have more than 2^32-2 commands in a transaction")));
1127 : }
1128 1150314 : currentCommandIdUsed = false;
1129 :
1130 : /* Propagate new command ID into static snapshots */
1131 1150314 : SnapshotSetCommandId(currentCommandId);
1132 :
1133 : /*
1134 : * Make any catalog changes done by the just-completed command visible
1135 : * in the local syscache. We obviously don't need to do this after a
1136 : * read-only command. (But see hacks in inval.c to make real sure we
1137 : * don't think a command that queued inval messages was read-only.)
1138 : */
1139 1150314 : AtCCI_LocalCache();
1140 : }
1141 2192598 : }
1142 :
1143 : /*
1144 : * ForceSyncCommit
1145 : *
1146 : * Interface routine to allow commands to force a synchronous commit of the
1147 : * current top-level transaction. Currently, two-phase commit does not
1148 : * persist and restore this variable. So long as all callers use
1149 : * PreventInTransactionBlock(), that omission has no consequences.
1150 : */
1151 : void
1152 990 : ForceSyncCommit(void)
1153 : {
1154 990 : forceSyncCommit = true;
1155 990 : }
1156 :
1157 :
1158 : /* ----------------------------------------------------------------
1159 : * StartTransaction stuff
1160 : * ----------------------------------------------------------------
1161 : */
1162 :
1163 : /*
1164 : * AtStart_Cache
1165 : */
1166 : static void
1167 1056948 : AtStart_Cache(void)
1168 : {
1169 1056948 : AcceptInvalidationMessages();
1170 1056948 : }
1171 :
1172 : /*
1173 : * AtStart_Memory
1174 : */
1175 : static void
1176 1056948 : AtStart_Memory(void)
1177 : {
1178 1056948 : TransactionState s = CurrentTransactionState;
1179 :
1180 : /*
1181 : * Remember the memory context that was active prior to transaction start.
1182 : */
1183 1056948 : s->priorContext = CurrentMemoryContext;
1184 :
1185 : /*
1186 : * If this is the first time through, create a private context for
1187 : * AbortTransaction to work in. By reserving some space now, we can
1188 : * insulate AbortTransaction from out-of-memory scenarios. Like
1189 : * ErrorContext, we set it up with slow growth rate and a nonzero minimum
1190 : * size, so that space will be reserved immediately.
1191 : */
1192 1056948 : if (TransactionAbortContext == NULL)
1193 34158 : TransactionAbortContext =
1194 34158 : AllocSetContextCreate(TopMemoryContext,
1195 : "TransactionAbortContext",
1196 : 32 * 1024,
1197 : 32 * 1024,
1198 : 32 * 1024);
1199 :
1200 : /*
1201 : * Likewise, if this is the first time through, create a top-level context
1202 : * for transaction-local data. This context will be reset at transaction
1203 : * end, and then re-used in later transactions.
1204 : */
1205 1056948 : if (TopTransactionContext == NULL)
1206 34158 : TopTransactionContext =
1207 34158 : AllocSetContextCreate(TopMemoryContext,
1208 : "TopTransactionContext",
1209 : ALLOCSET_DEFAULT_SIZES);
1210 :
1211 : /*
1212 : * In a top-level transaction, CurTransactionContext is the same as
1213 : * TopTransactionContext.
1214 : */
1215 1056948 : CurTransactionContext = TopTransactionContext;
1216 1056948 : s->curTransactionContext = CurTransactionContext;
1217 :
1218 : /* Make the CurTransactionContext active. */
1219 1056948 : MemoryContextSwitchTo(CurTransactionContext);
1220 1056948 : }
1221 :
1222 : /*
1223 : * AtStart_ResourceOwner
1224 : */
1225 : static void
1226 1056948 : AtStart_ResourceOwner(void)
1227 : {
1228 1056948 : TransactionState s = CurrentTransactionState;
1229 :
1230 : /*
1231 : * We shouldn't have a transaction resource owner already.
1232 : */
1233 : Assert(TopTransactionResourceOwner == NULL);
1234 :
1235 : /*
1236 : * Create a toplevel resource owner for the transaction.
1237 : */
1238 1056948 : s->curTransactionOwner = ResourceOwnerCreate(NULL, "TopTransaction");
1239 :
1240 1056948 : TopTransactionResourceOwner = s->curTransactionOwner;
1241 1056948 : CurTransactionResourceOwner = s->curTransactionOwner;
1242 1056948 : CurrentResourceOwner = s->curTransactionOwner;
1243 1056948 : }
1244 :
1245 : /* ----------------------------------------------------------------
1246 : * StartSubTransaction stuff
1247 : * ----------------------------------------------------------------
1248 : */
1249 :
1250 : /*
1251 : * AtSubStart_Memory
1252 : */
1253 : static void
1254 20052 : AtSubStart_Memory(void)
1255 : {
1256 20052 : TransactionState s = CurrentTransactionState;
1257 :
1258 : Assert(CurTransactionContext != NULL);
1259 :
1260 : /*
1261 : * Remember the context that was active prior to subtransaction start.
1262 : */
1263 20052 : s->priorContext = CurrentMemoryContext;
1264 :
1265 : /*
1266 : * Create a CurTransactionContext, which will be used to hold data that
1267 : * survives subtransaction commit but disappears on subtransaction abort.
1268 : * We make it a child of the immediate parent's CurTransactionContext.
1269 : */
1270 20052 : CurTransactionContext = AllocSetContextCreate(CurTransactionContext,
1271 : "CurTransactionContext",
1272 : ALLOCSET_DEFAULT_SIZES);
1273 20052 : s->curTransactionContext = CurTransactionContext;
1274 :
1275 : /* Make the CurTransactionContext active. */
1276 20052 : MemoryContextSwitchTo(CurTransactionContext);
1277 20052 : }
1278 :
1279 : /*
1280 : * AtSubStart_ResourceOwner
1281 : */
1282 : static void
1283 20052 : AtSubStart_ResourceOwner(void)
1284 : {
1285 20052 : TransactionState s = CurrentTransactionState;
1286 :
1287 : Assert(s->parent != NULL);
1288 :
1289 : /*
1290 : * Create a resource owner for the subtransaction. We make it a child of
1291 : * the immediate parent's resource owner.
1292 : */
1293 20052 : s->curTransactionOwner =
1294 20052 : ResourceOwnerCreate(s->parent->curTransactionOwner,
1295 : "SubTransaction");
1296 :
1297 20052 : CurTransactionResourceOwner = s->curTransactionOwner;
1298 20052 : CurrentResourceOwner = s->curTransactionOwner;
1299 20052 : }
1300 :
1301 : /* ----------------------------------------------------------------
1302 : * CommitTransaction stuff
1303 : * ----------------------------------------------------------------
1304 : */
1305 :
1306 : /*
1307 : * RecordTransactionCommit
1308 : *
1309 : * Returns latest XID among xact and its children, or InvalidTransactionId
1310 : * if the xact has no XID. (We compute that here just because it's easier.)
1311 : *
1312 : * If you change this function, see RecordTransactionCommitPrepared also.
1313 : */
1314 : static TransactionId
1315 1004318 : RecordTransactionCommit(void)
1316 : {
1317 1004318 : TransactionId xid = GetTopTransactionIdIfAny();
1318 1004318 : bool markXidCommitted = TransactionIdIsValid(xid);
1319 1004318 : TransactionId latestXid = InvalidTransactionId;
1320 : int nrels;
1321 : RelFileLocator *rels;
1322 : int nchildren;
1323 : TransactionId *children;
1324 1004318 : int ndroppedstats = 0;
1325 1004318 : xl_xact_stats_item *droppedstats = NULL;
1326 1004318 : int nmsgs = 0;
1327 1004318 : SharedInvalidationMessage *invalMessages = NULL;
1328 1004318 : bool RelcacheInitFileInval = false;
1329 : bool wrote_xlog;
1330 :
1331 : /*
1332 : * Log pending invalidations for logical decoding of in-progress
1333 : * transactions. Normally for DDLs, we log this at each command end,
1334 : * however, for certain cases where we directly update the system table
1335 : * without a transaction block, the invalidations are not logged till this
1336 : * time.
1337 : */
1338 1004318 : if (XLogLogicalInfoActive())
1339 25156 : LogLogicalInvalidations();
1340 :
1341 : /* Get data needed for commit record */
1342 1004318 : nrels = smgrGetPendingDeletes(true, &rels);
1343 1004318 : nchildren = xactGetCommittedChildren(&children);
1344 1004318 : ndroppedstats = pgstat_get_transactional_drops(true, &droppedstats);
1345 1004318 : if (XLogStandbyInfoActive())
1346 403112 : nmsgs = xactGetCommittedInvalidationMessages(&invalMessages,
1347 : &RelcacheInitFileInval);
1348 1004318 : wrote_xlog = (XactLastRecEnd != 0);
1349 :
1350 : /*
1351 : * If we haven't been assigned an XID yet, we neither can, nor do we want
1352 : * to write a COMMIT record.
1353 : */
1354 1004318 : if (!markXidCommitted)
1355 : {
1356 : /*
1357 : * We expect that every RelationDropStorage is followed by a catalog
1358 : * update, and hence XID assignment, so we shouldn't get here with any
1359 : * pending deletes. Same is true for dropping stats.
1360 : *
1361 : * Use a real test not just an Assert to check this, since it's a bit
1362 : * fragile.
1363 : */
1364 750978 : if (nrels != 0 || ndroppedstats != 0)
1365 0 : elog(ERROR, "cannot commit a transaction that deleted files but has no xid");
1366 :
1367 : /* Can't have child XIDs either; AssignTransactionId enforces this */
1368 : Assert(nchildren == 0);
1369 :
1370 : /*
1371 : * Transactions without an assigned xid can contain invalidation
1372 : * messages. While inplace updates do this, this is not known to be
1373 : * necessary; see comment at inplace CacheInvalidateHeapTuple().
1374 : * Extensions might still rely on this capability, and standbys may
1375 : * need to process those invals. We can't emit a commit record
1376 : * without an xid, and we don't want to force assigning an xid,
1377 : * because that'd be problematic for e.g. vacuum. Hence we emit a
1378 : * bespoke record for the invalidations. We don't want to use that in
1379 : * case a commit record is emitted, so they happen synchronously with
1380 : * commits (besides not wanting to emit more WAL records).
1381 : *
1382 : * XXX Every known use of this capability is a defect. Since an XID
1383 : * isn't controlling visibility of the change that prompted invals,
1384 : * other sessions need the inval even if this transactions aborts.
1385 : *
1386 : * ON COMMIT DELETE ROWS does a nontransactional index_build(), which
1387 : * queues a relcache inval, including in transactions without an xid
1388 : * that had read the (empty) table. Standbys don't need any ON COMMIT
1389 : * DELETE ROWS invals, but we've not done the work to withhold them.
1390 : */
1391 750978 : if (nmsgs != 0)
1392 : {
1393 18248 : LogStandbyInvalidations(nmsgs, invalMessages,
1394 : RelcacheInitFileInval);
1395 18248 : wrote_xlog = true; /* not strictly necessary */
1396 : }
1397 :
1398 : /*
1399 : * If we didn't create XLOG entries, we're done here; otherwise we
1400 : * should trigger flushing those entries the same as a commit record
1401 : * would. This will primarily happen for HOT pruning and the like; we
1402 : * want these to be flushed to disk in due time.
1403 : */
1404 750978 : if (!wrote_xlog)
1405 678666 : goto cleanup;
1406 : }
1407 : else
1408 : {
1409 : bool replorigin;
1410 :
1411 : /*
1412 : * Are we using the replication origins feature? Or, in other words,
1413 : * are we replaying remote actions?
1414 : */
1415 255326 : replorigin = (replorigin_session_origin != InvalidRepOriginId &&
1416 1986 : replorigin_session_origin != DoNotReplicateId);
1417 :
1418 : /*
1419 : * Mark ourselves as within our "commit critical section". This
1420 : * forces any concurrent checkpoint to wait until we've updated
1421 : * pg_xact. Without this, it is possible for the checkpoint to set
1422 : * REDO after the XLOG record but fail to flush the pg_xact update to
1423 : * disk, leading to loss of the transaction commit if the system
1424 : * crashes a little later.
1425 : *
1426 : * Note: we could, but don't bother to, set this flag in
1427 : * RecordTransactionAbort. That's because loss of a transaction abort
1428 : * is noncritical; the presumption would be that it aborted, anyway.
1429 : *
1430 : * It's safe to change the delayChkptFlags flag of our own backend
1431 : * without holding the ProcArrayLock, since we're the only one
1432 : * modifying it. This makes checkpoint's determination of which xacts
1433 : * are delaying the checkpoint a bit fuzzy, but it doesn't matter.
1434 : *
1435 : * Note, it is important to get the commit timestamp after marking the
1436 : * transaction in the commit critical section. See
1437 : * RecordTransactionCommitPrepared.
1438 : */
1439 : Assert((MyProc->delayChkptFlags & DELAY_CHKPT_IN_COMMIT) == 0);
1440 253340 : START_CRIT_SECTION();
1441 253340 : MyProc->delayChkptFlags |= DELAY_CHKPT_IN_COMMIT;
1442 :
1443 : Assert(xactStopTimestamp == 0);
1444 :
1445 : /*
1446 : * Ensures the DELAY_CHKPT_IN_COMMIT flag write is globally visible
1447 : * before commit time is written.
1448 : */
1449 253340 : pg_write_barrier();
1450 :
1451 : /*
1452 : * Insert the commit XLOG record.
1453 : */
1454 253340 : XactLogCommitRecord(GetCurrentTransactionStopTimestamp(),
1455 : nchildren, children, nrels, rels,
1456 : ndroppedstats, droppedstats,
1457 : nmsgs, invalMessages,
1458 : RelcacheInitFileInval,
1459 : MyXactFlags,
1460 : InvalidTransactionId, NULL /* plain commit */ );
1461 :
1462 253340 : if (replorigin)
1463 : /* Move LSNs forward for this replication origin */
1464 1986 : replorigin_session_advance(replorigin_session_origin_lsn,
1465 : XactLastRecEnd);
1466 :
1467 : /*
1468 : * Record commit timestamp. The value comes from plain commit
1469 : * timestamp if there's no replication origin; otherwise, the
1470 : * timestamp was already set in replorigin_session_origin_timestamp by
1471 : * replication.
1472 : *
1473 : * We don't need to WAL-log anything here, as the commit record
1474 : * written above already contains the data.
1475 : */
1476 :
1477 253340 : if (!replorigin || replorigin_session_origin_timestamp == 0)
1478 251548 : replorigin_session_origin_timestamp = GetCurrentTransactionStopTimestamp();
1479 :
1480 253340 : TransactionTreeSetCommitTsData(xid, nchildren, children,
1481 : replorigin_session_origin_timestamp,
1482 : replorigin_session_origin);
1483 : }
1484 :
1485 : /*
1486 : * Check if we want to commit asynchronously. We can allow the XLOG flush
1487 : * to happen asynchronously if synchronous_commit=off, or if the current
1488 : * transaction has not performed any WAL-logged operation or didn't assign
1489 : * an xid. The transaction can end up not writing any WAL, even if it has
1490 : * an xid, if it only wrote to temporary and/or unlogged tables. It can
1491 : * end up having written WAL without an xid if it did HOT pruning. In
1492 : * case of a crash, the loss of such a transaction will be irrelevant;
1493 : * temp tables will be lost anyway, unlogged tables will be truncated and
1494 : * HOT pruning will be done again later. (Given the foregoing, you might
1495 : * think that it would be unnecessary to emit the XLOG record at all in
1496 : * this case, but we don't currently try to do that. It would certainly
1497 : * cause problems at least in Hot Standby mode, where the
1498 : * KnownAssignedXids machinery requires tracking every XID assignment. It
1499 : * might be OK to skip it only when wal_level < replica, but for now we
1500 : * don't.)
1501 : *
1502 : * However, if we're doing cleanup of any non-temp rels or committing any
1503 : * command that wanted to force sync commit, then we must flush XLOG
1504 : * immediately. (We must not allow asynchronous commit if there are any
1505 : * non-temp tables to be deleted, because we might delete the files before
1506 : * the COMMIT record is flushed to disk. We do allow asynchronous commit
1507 : * if all to-be-deleted tables are temporary though, since they are lost
1508 : * anyway if we crash.)
1509 : */
1510 325652 : if ((wrote_xlog && markXidCommitted &&
1511 325652 : synchronous_commit > SYNCHRONOUS_COMMIT_OFF) ||
1512 84552 : forceSyncCommit || nrels > 0)
1513 : {
1514 241136 : XLogFlush(XactLastRecEnd);
1515 :
1516 : /*
1517 : * Now we may update the CLOG, if we wrote a COMMIT record above
1518 : */
1519 241136 : if (markXidCommitted)
1520 241136 : TransactionIdCommitTree(xid, nchildren, children);
1521 : }
1522 : else
1523 : {
1524 : /*
1525 : * Asynchronous commit case:
1526 : *
1527 : * This enables possible committed transaction loss in the case of a
1528 : * postmaster crash because WAL buffers are left unwritten. Ideally we
1529 : * could issue the WAL write without the fsync, but some
1530 : * wal_sync_methods do not allow separate write/fsync.
1531 : *
1532 : * Report the latest async commit LSN, so that the WAL writer knows to
1533 : * flush this commit.
1534 : */
1535 84516 : XLogSetAsyncXactLSN(XactLastRecEnd);
1536 :
1537 : /*
1538 : * We must not immediately update the CLOG, since we didn't flush the
1539 : * XLOG. Instead, we store the LSN up to which the XLOG must be
1540 : * flushed before the CLOG may be updated.
1541 : */
1542 84516 : if (markXidCommitted)
1543 12204 : TransactionIdAsyncCommitTree(xid, nchildren, children, XactLastRecEnd);
1544 : }
1545 :
1546 : /*
1547 : * If we entered a commit critical section, leave it now, and let
1548 : * checkpoints proceed.
1549 : */
1550 325652 : if (markXidCommitted)
1551 : {
1552 253340 : MyProc->delayChkptFlags &= ~DELAY_CHKPT_IN_COMMIT;
1553 253340 : END_CRIT_SECTION();
1554 : }
1555 :
1556 : /* Compute latestXid while we have the child XIDs handy */
1557 325652 : latestXid = TransactionIdLatest(xid, nchildren, children);
1558 :
1559 : /*
1560 : * Wait for synchronous replication, if required. Similar to the decision
1561 : * above about using committing asynchronously we only want to wait if
1562 : * this backend assigned an xid and wrote WAL. No need to wait if an xid
1563 : * was assigned due to temporary/unlogged tables or due to HOT pruning.
1564 : *
1565 : * Note that at this stage we have marked clog, but still show as running
1566 : * in the procarray and continue to hold locks.
1567 : */
1568 325652 : if (wrote_xlog && markXidCommitted)
1569 245414 : SyncRepWaitForLSN(XactLastRecEnd, true);
1570 :
1571 : /* remember end of last commit record */
1572 325652 : XactLastCommitEnd = XactLastRecEnd;
1573 :
1574 : /* Reset XactLastRecEnd until the next transaction writes something */
1575 325652 : XactLastRecEnd = 0;
1576 1004318 : cleanup:
1577 : /* Clean up local data */
1578 1004318 : if (rels)
1579 19540 : pfree(rels);
1580 1004318 : if (ndroppedstats)
1581 21160 : pfree(droppedstats);
1582 :
1583 1004318 : return latestXid;
1584 : }
1585 :
1586 :
1587 : /*
1588 : * AtCCI_LocalCache
1589 : */
1590 : static void
1591 1150314 : AtCCI_LocalCache(void)
1592 : {
1593 : /*
1594 : * Make any pending relation map changes visible. We must do this before
1595 : * processing local sinval messages, so that the map changes will get
1596 : * reflected into the relcache when relcache invals are processed.
1597 : */
1598 1150314 : AtCCI_RelationMap();
1599 :
1600 : /*
1601 : * Make catalog changes visible to me for the next command.
1602 : */
1603 1150314 : CommandEndInvalidationMessages();
1604 1150308 : }
1605 :
1606 : /*
1607 : * AtCommit_Memory
1608 : */
1609 : static void
1610 1007622 : AtCommit_Memory(void)
1611 : {
1612 1007622 : TransactionState s = CurrentTransactionState;
1613 :
1614 : /*
1615 : * Return to the memory context that was current before we started the
1616 : * transaction. (In principle, this could not be any of the contexts we
1617 : * are about to delete. If it somehow is, assertions in mcxt.c will
1618 : * complain.)
1619 : */
1620 1007622 : MemoryContextSwitchTo(s->priorContext);
1621 :
1622 : /*
1623 : * Release all transaction-local memory. TopTransactionContext survives
1624 : * but becomes empty; any sub-contexts go away.
1625 : */
1626 : Assert(TopTransactionContext != NULL);
1627 1007622 : MemoryContextReset(TopTransactionContext);
1628 :
1629 : /*
1630 : * Clear these pointers as a pro-forma matter. (Notionally, while
1631 : * TopTransactionContext still exists, it's currently not associated with
1632 : * this TransactionState struct.)
1633 : */
1634 1007622 : CurTransactionContext = NULL;
1635 1007622 : s->curTransactionContext = NULL;
1636 1007622 : }
1637 :
1638 : /* ----------------------------------------------------------------
1639 : * CommitSubTransaction stuff
1640 : * ----------------------------------------------------------------
1641 : */
1642 :
1643 : /*
1644 : * AtSubCommit_Memory
1645 : */
1646 : static void
1647 10686 : AtSubCommit_Memory(void)
1648 : {
1649 10686 : TransactionState s = CurrentTransactionState;
1650 :
1651 : Assert(s->parent != NULL);
1652 :
1653 : /* Return to parent transaction level's memory context. */
1654 10686 : CurTransactionContext = s->parent->curTransactionContext;
1655 10686 : MemoryContextSwitchTo(CurTransactionContext);
1656 :
1657 : /*
1658 : * Ordinarily we cannot throw away the child's CurTransactionContext,
1659 : * since the data it contains will be needed at upper commit. However, if
1660 : * there isn't actually anything in it, we can throw it away. This avoids
1661 : * a small memory leak in the common case of "trivial" subxacts.
1662 : */
1663 10686 : if (MemoryContextIsEmpty(s->curTransactionContext))
1664 : {
1665 10668 : MemoryContextDelete(s->curTransactionContext);
1666 10668 : s->curTransactionContext = NULL;
1667 : }
1668 10686 : }
1669 :
1670 : /*
1671 : * AtSubCommit_childXids
1672 : *
1673 : * Pass my own XID and my child XIDs up to my parent as committed children.
1674 : */
1675 : static void
1676 7366 : AtSubCommit_childXids(void)
1677 : {
1678 7366 : TransactionState s = CurrentTransactionState;
1679 : int new_nChildXids;
1680 :
1681 : Assert(s->parent != NULL);
1682 :
1683 : /*
1684 : * The parent childXids array will need to hold my XID and all my
1685 : * childXids, in addition to the XIDs already there.
1686 : */
1687 7366 : new_nChildXids = s->parent->nChildXids + s->nChildXids + 1;
1688 :
1689 : /* Allocate or enlarge the parent array if necessary */
1690 7366 : if (s->parent->maxChildXids < new_nChildXids)
1691 : {
1692 : int new_maxChildXids;
1693 : TransactionId *new_childXids;
1694 :
1695 : /*
1696 : * Make it 2x what's needed right now, to avoid having to enlarge it
1697 : * repeatedly. But we can't go above MaxAllocSize. (The latter limit
1698 : * is what ensures that we don't need to worry about integer overflow
1699 : * here or in the calculation of new_nChildXids.)
1700 : */
1701 3298 : new_maxChildXids = Min(new_nChildXids * 2,
1702 : (int) (MaxAllocSize / sizeof(TransactionId)));
1703 :
1704 3298 : if (new_maxChildXids < new_nChildXids)
1705 0 : ereport(ERROR,
1706 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1707 : errmsg("maximum number of committed subtransactions (%d) exceeded",
1708 : (int) (MaxAllocSize / sizeof(TransactionId)))));
1709 :
1710 : /*
1711 : * We keep the child-XID arrays in TopTransactionContext; this avoids
1712 : * setting up child-transaction contexts for what might be just a few
1713 : * bytes of grandchild XIDs.
1714 : */
1715 3298 : if (s->parent->childXids == NULL)
1716 : new_childXids =
1717 3214 : MemoryContextAlloc(TopTransactionContext,
1718 : new_maxChildXids * sizeof(TransactionId));
1719 : else
1720 84 : new_childXids = repalloc(s->parent->childXids,
1721 : new_maxChildXids * sizeof(TransactionId));
1722 :
1723 3298 : s->parent->childXids = new_childXids;
1724 3298 : s->parent->maxChildXids = new_maxChildXids;
1725 : }
1726 :
1727 : /*
1728 : * Copy all my XIDs to parent's array.
1729 : *
1730 : * Note: We rely on the fact that the XID of a child always follows that
1731 : * of its parent. By copying the XID of this subtransaction before the
1732 : * XIDs of its children, we ensure that the array stays ordered. Likewise,
1733 : * all XIDs already in the array belong to subtransactions started and
1734 : * subcommitted before us, so their XIDs must precede ours.
1735 : */
1736 7366 : s->parent->childXids[s->parent->nChildXids] = XidFromFullTransactionId(s->fullTransactionId);
1737 :
1738 7366 : if (s->nChildXids > 0)
1739 2016 : memcpy(&s->parent->childXids[s->parent->nChildXids + 1],
1740 2016 : s->childXids,
1741 2016 : s->nChildXids * sizeof(TransactionId));
1742 :
1743 7366 : s->parent->nChildXids = new_nChildXids;
1744 :
1745 : /* Release child's array to avoid leakage */
1746 7366 : if (s->childXids != NULL)
1747 2016 : pfree(s->childXids);
1748 : /* We must reset these to avoid double-free if fail later in commit */
1749 7366 : s->childXids = NULL;
1750 7366 : s->nChildXids = 0;
1751 7366 : s->maxChildXids = 0;
1752 7366 : }
1753 :
1754 : /* ----------------------------------------------------------------
1755 : * AbortTransaction stuff
1756 : * ----------------------------------------------------------------
1757 : */
1758 :
1759 : /*
1760 : * RecordTransactionAbort
1761 : *
1762 : * Returns latest XID among xact and its children, or InvalidTransactionId
1763 : * if the xact has no XID. (We compute that here just because it's easier.)
1764 : */
1765 : static TransactionId
1766 58680 : RecordTransactionAbort(bool isSubXact)
1767 : {
1768 58680 : TransactionId xid = GetCurrentTransactionIdIfAny();
1769 : TransactionId latestXid;
1770 : int nrels;
1771 : RelFileLocator *rels;
1772 58680 : int ndroppedstats = 0;
1773 58680 : xl_xact_stats_item *droppedstats = NULL;
1774 : int nchildren;
1775 : TransactionId *children;
1776 : TimestampTz xact_time;
1777 : bool replorigin;
1778 :
1779 : /*
1780 : * If we haven't been assigned an XID, nobody will care whether we aborted
1781 : * or not. Hence, we're done in that case. It does not matter if we have
1782 : * rels to delete (note that this routine is not responsible for actually
1783 : * deleting 'em). We cannot have any child XIDs, either.
1784 : */
1785 58680 : if (!TransactionIdIsValid(xid))
1786 : {
1787 : /* Reset XactLastRecEnd until the next transaction writes something */
1788 46848 : if (!isSubXact)
1789 38780 : XactLastRecEnd = 0;
1790 46848 : return InvalidTransactionId;
1791 : }
1792 :
1793 : /*
1794 : * We have a valid XID, so we should write an ABORT record for it.
1795 : *
1796 : * We do not flush XLOG to disk here, since the default assumption after a
1797 : * crash would be that we aborted, anyway. For the same reason, we don't
1798 : * need to worry about interlocking against checkpoint start.
1799 : */
1800 :
1801 : /*
1802 : * Check that we haven't aborted halfway through RecordTransactionCommit.
1803 : */
1804 11832 : if (TransactionIdDidCommit(xid))
1805 0 : elog(PANIC, "cannot abort transaction %u, it was already committed",
1806 : xid);
1807 :
1808 : /*
1809 : * Are we using the replication origins feature? Or, in other words, are
1810 : * we replaying remote actions?
1811 : */
1812 11886 : replorigin = (replorigin_session_origin != InvalidRepOriginId &&
1813 54 : replorigin_session_origin != DoNotReplicateId);
1814 :
1815 : /* Fetch the data we need for the abort record */
1816 11832 : nrels = smgrGetPendingDeletes(false, &rels);
1817 11832 : nchildren = xactGetCommittedChildren(&children);
1818 11832 : ndroppedstats = pgstat_get_transactional_drops(false, &droppedstats);
1819 :
1820 : /* XXX do we really need a critical section here? */
1821 11832 : START_CRIT_SECTION();
1822 :
1823 : /* Write the ABORT record */
1824 11832 : if (isSubXact)
1825 1298 : xact_time = GetCurrentTimestamp();
1826 : else
1827 : {
1828 10534 : xact_time = GetCurrentTransactionStopTimestamp();
1829 : }
1830 :
1831 11832 : XactLogAbortRecord(xact_time,
1832 : nchildren, children,
1833 : nrels, rels,
1834 : ndroppedstats, droppedstats,
1835 : MyXactFlags, InvalidTransactionId,
1836 : NULL);
1837 :
1838 11832 : if (replorigin)
1839 : /* Move LSNs forward for this replication origin */
1840 54 : replorigin_session_advance(replorigin_session_origin_lsn,
1841 : XactLastRecEnd);
1842 :
1843 : /*
1844 : * Report the latest async abort LSN, so that the WAL writer knows to
1845 : * flush this abort. There's nothing to be gained by delaying this, since
1846 : * WALWriter may as well do this when it can. This is important with
1847 : * streaming replication because if we don't flush WAL regularly we will
1848 : * find that large aborts leave us with a long backlog for when commits
1849 : * occur after the abort, increasing our window of data loss should
1850 : * problems occur at that point.
1851 : */
1852 11832 : if (!isSubXact)
1853 10534 : XLogSetAsyncXactLSN(XactLastRecEnd);
1854 :
1855 : /*
1856 : * Mark the transaction aborted in clog. This is not absolutely necessary
1857 : * but we may as well do it while we are here; also, in the subxact case
1858 : * it is helpful because XactLockTableWait makes use of it to avoid
1859 : * waiting for already-aborted subtransactions. It is OK to do it without
1860 : * having flushed the ABORT record to disk, because in event of a crash
1861 : * we'd be assumed to have aborted anyway.
1862 : */
1863 11832 : TransactionIdAbortTree(xid, nchildren, children);
1864 :
1865 11832 : END_CRIT_SECTION();
1866 :
1867 : /* Compute latestXid while we have the child XIDs handy */
1868 11832 : latestXid = TransactionIdLatest(xid, nchildren, children);
1869 :
1870 : /*
1871 : * If we're aborting a subtransaction, we can immediately remove failed
1872 : * XIDs from PGPROC's cache of running child XIDs. We do that here for
1873 : * subxacts, because we already have the child XID array at hand. For
1874 : * main xacts, the equivalent happens just after this function returns.
1875 : */
1876 11832 : if (isSubXact)
1877 1298 : XidCacheRemoveRunningXids(xid, nchildren, children, latestXid);
1878 :
1879 : /* Reset XactLastRecEnd until the next transaction writes something */
1880 11832 : if (!isSubXact)
1881 10534 : XactLastRecEnd = 0;
1882 :
1883 : /* And clean up local data */
1884 11832 : if (rels)
1885 1998 : pfree(rels);
1886 11832 : if (ndroppedstats)
1887 2736 : pfree(droppedstats);
1888 :
1889 11832 : return latestXid;
1890 : }
1891 :
1892 : /*
1893 : * AtAbort_Memory
1894 : */
1895 : static void
1896 84242 : AtAbort_Memory(void)
1897 : {
1898 : /*
1899 : * Switch into TransactionAbortContext, which should have some free space
1900 : * even if nothing else does. We'll work in this context until we've
1901 : * finished cleaning up.
1902 : *
1903 : * It is barely possible to get here when we've not been able to create
1904 : * TransactionAbortContext yet; if so use TopMemoryContext.
1905 : */
1906 84242 : if (TransactionAbortContext != NULL)
1907 84242 : MemoryContextSwitchTo(TransactionAbortContext);
1908 : else
1909 0 : MemoryContextSwitchTo(TopMemoryContext);
1910 84242 : }
1911 :
1912 : /*
1913 : * AtSubAbort_Memory
1914 : */
1915 : static void
1916 9366 : AtSubAbort_Memory(void)
1917 : {
1918 : Assert(TransactionAbortContext != NULL);
1919 :
1920 9366 : MemoryContextSwitchTo(TransactionAbortContext);
1921 9366 : }
1922 :
1923 :
1924 : /*
1925 : * AtAbort_ResourceOwner
1926 : */
1927 : static void
1928 49326 : AtAbort_ResourceOwner(void)
1929 : {
1930 : /*
1931 : * Make sure we have a valid ResourceOwner, if possible (else it will be
1932 : * NULL, which is OK)
1933 : */
1934 49326 : CurrentResourceOwner = TopTransactionResourceOwner;
1935 49326 : }
1936 :
1937 : /*
1938 : * AtSubAbort_ResourceOwner
1939 : */
1940 : static void
1941 9366 : AtSubAbort_ResourceOwner(void)
1942 : {
1943 9366 : TransactionState s = CurrentTransactionState;
1944 :
1945 : /* Make sure we have a valid ResourceOwner */
1946 9366 : CurrentResourceOwner = s->curTransactionOwner;
1947 9366 : }
1948 :
1949 :
1950 : /*
1951 : * AtSubAbort_childXids
1952 : */
1953 : static void
1954 1298 : AtSubAbort_childXids(void)
1955 : {
1956 1298 : TransactionState s = CurrentTransactionState;
1957 :
1958 : /*
1959 : * We keep the child-XID arrays in TopTransactionContext (see
1960 : * AtSubCommit_childXids). This means we'd better free the array
1961 : * explicitly at abort to avoid leakage.
1962 : */
1963 1298 : if (s->childXids != NULL)
1964 50 : pfree(s->childXids);
1965 1298 : s->childXids = NULL;
1966 1298 : s->nChildXids = 0;
1967 1298 : s->maxChildXids = 0;
1968 :
1969 : /*
1970 : * We could prune the unreportedXids array here. But we don't bother. That
1971 : * would potentially reduce number of XLOG_XACT_ASSIGNMENT records but it
1972 : * would likely introduce more CPU time into the more common paths, so we
1973 : * choose not to do that.
1974 : */
1975 1298 : }
1976 :
1977 : /* ----------------------------------------------------------------
1978 : * CleanupTransaction stuff
1979 : * ----------------------------------------------------------------
1980 : */
1981 :
1982 : /*
1983 : * AtCleanup_Memory
1984 : */
1985 : static void
1986 49326 : AtCleanup_Memory(void)
1987 : {
1988 49326 : TransactionState s = CurrentTransactionState;
1989 :
1990 : /* Should be at top level */
1991 : Assert(s->parent == NULL);
1992 :
1993 : /*
1994 : * Return to the memory context that was current before we started the
1995 : * transaction. (In principle, this could not be any of the contexts we
1996 : * are about to delete. If it somehow is, assertions in mcxt.c will
1997 : * complain.)
1998 : */
1999 49326 : MemoryContextSwitchTo(s->priorContext);
2000 :
2001 : /*
2002 : * Clear the special abort context for next time.
2003 : */
2004 49326 : if (TransactionAbortContext != NULL)
2005 49326 : MemoryContextReset(TransactionAbortContext);
2006 :
2007 : /*
2008 : * Release all transaction-local memory, the same as in AtCommit_Memory,
2009 : * except we must cope with the possibility that we didn't get as far as
2010 : * creating TopTransactionContext.
2011 : */
2012 49326 : if (TopTransactionContext != NULL)
2013 49326 : MemoryContextReset(TopTransactionContext);
2014 :
2015 : /*
2016 : * Clear these pointers as a pro-forma matter. (Notionally, while
2017 : * TopTransactionContext still exists, it's currently not associated with
2018 : * this TransactionState struct.)
2019 : */
2020 49326 : CurTransactionContext = NULL;
2021 49326 : s->curTransactionContext = NULL;
2022 49326 : }
2023 :
2024 :
2025 : /* ----------------------------------------------------------------
2026 : * CleanupSubTransaction stuff
2027 : * ----------------------------------------------------------------
2028 : */
2029 :
2030 : /*
2031 : * AtSubCleanup_Memory
2032 : */
2033 : static void
2034 9366 : AtSubCleanup_Memory(void)
2035 : {
2036 9366 : TransactionState s = CurrentTransactionState;
2037 :
2038 : Assert(s->parent != NULL);
2039 :
2040 : /*
2041 : * Return to the memory context that was current before we started the
2042 : * subtransaction. (In principle, this could not be any of the contexts
2043 : * we are about to delete. If it somehow is, assertions in mcxt.c will
2044 : * complain.)
2045 : */
2046 9366 : MemoryContextSwitchTo(s->priorContext);
2047 :
2048 : /* Update CurTransactionContext (might not be same as priorContext) */
2049 9366 : CurTransactionContext = s->parent->curTransactionContext;
2050 :
2051 : /*
2052 : * Clear the special abort context for next time.
2053 : */
2054 9366 : if (TransactionAbortContext != NULL)
2055 9366 : MemoryContextReset(TransactionAbortContext);
2056 :
2057 : /*
2058 : * Delete the subxact local memory contexts. Its CurTransactionContext can
2059 : * go too (note this also kills CurTransactionContexts from any children
2060 : * of the subxact).
2061 : */
2062 9366 : if (s->curTransactionContext)
2063 9366 : MemoryContextDelete(s->curTransactionContext);
2064 9366 : s->curTransactionContext = NULL;
2065 9366 : }
2066 :
2067 : /* ----------------------------------------------------------------
2068 : * interface routines
2069 : * ----------------------------------------------------------------
2070 : */
2071 :
2072 : /*
2073 : * StartTransaction
2074 : */
2075 : static void
2076 1056948 : StartTransaction(void)
2077 : {
2078 : TransactionState s;
2079 : VirtualTransactionId vxid;
2080 :
2081 : /*
2082 : * Let's just make sure the state stack is empty
2083 : */
2084 1056948 : s = &TopTransactionStateData;
2085 1056948 : CurrentTransactionState = s;
2086 :
2087 : Assert(!FullTransactionIdIsValid(XactTopFullTransactionId));
2088 :
2089 : /* check the current transaction state */
2090 : Assert(s->state == TRANS_DEFAULT);
2091 :
2092 : /*
2093 : * Set the current transaction state information appropriately during
2094 : * start processing. Note that once the transaction status is switched
2095 : * this process cannot fail until the user ID and the security context
2096 : * flags are fetched below.
2097 : */
2098 1056948 : s->state = TRANS_START;
2099 1056948 : s->fullTransactionId = InvalidFullTransactionId; /* until assigned */
2100 :
2101 : /* Determine if statements are logged in this transaction */
2102 1056948 : xact_is_sampled = log_xact_sample_rate != 0 &&
2103 0 : (log_xact_sample_rate == 1 ||
2104 0 : pg_prng_double(&pg_global_prng_state) <= log_xact_sample_rate);
2105 :
2106 : /*
2107 : * initialize current transaction state fields
2108 : *
2109 : * note: prevXactReadOnly is not used at the outermost level
2110 : */
2111 1056948 : s->nestingLevel = 1;
2112 1056948 : s->gucNestLevel = 1;
2113 1056948 : s->childXids = NULL;
2114 1056948 : s->nChildXids = 0;
2115 1056948 : s->maxChildXids = 0;
2116 :
2117 : /*
2118 : * Once the current user ID and the security context flags are fetched,
2119 : * both will be properly reset even if transaction startup fails.
2120 : */
2121 1056948 : GetUserIdAndSecContext(&s->prevUser, &s->prevSecContext);
2122 :
2123 : /* SecurityRestrictionContext should never be set outside a transaction */
2124 : Assert(s->prevSecContext == 0);
2125 :
2126 : /*
2127 : * Make sure we've reset xact state variables
2128 : *
2129 : * If recovery is still in progress, mark this transaction as read-only.
2130 : * We have lower level defences in XLogInsert and elsewhere to stop us
2131 : * from modifying data during recovery, but this gives the normal
2132 : * indication to the user that the transaction is read-only.
2133 : */
2134 1056948 : if (RecoveryInProgress())
2135 : {
2136 3322 : s->startedInRecovery = true;
2137 3322 : XactReadOnly = true;
2138 : }
2139 : else
2140 : {
2141 1053626 : s->startedInRecovery = false;
2142 1053626 : XactReadOnly = DefaultXactReadOnly;
2143 : }
2144 1056948 : XactDeferrable = DefaultXactDeferrable;
2145 1056948 : XactIsoLevel = DefaultXactIsoLevel;
2146 1056948 : forceSyncCommit = false;
2147 1056948 : MyXactFlags = 0;
2148 :
2149 : /*
2150 : * reinitialize within-transaction counters
2151 : */
2152 1056948 : s->subTransactionId = TopSubTransactionId;
2153 1056948 : currentSubTransactionId = TopSubTransactionId;
2154 1056948 : currentCommandId = FirstCommandId;
2155 1056948 : currentCommandIdUsed = false;
2156 :
2157 : /*
2158 : * initialize reported xid accounting
2159 : */
2160 1056948 : nUnreportedXids = 0;
2161 1056948 : s->didLogXid = false;
2162 :
2163 : /*
2164 : * must initialize resource-management stuff first
2165 : */
2166 1056948 : AtStart_Memory();
2167 1056948 : AtStart_ResourceOwner();
2168 :
2169 : /*
2170 : * Assign a new LocalTransactionId, and combine it with the proc number to
2171 : * form a virtual transaction id.
2172 : */
2173 1056948 : vxid.procNumber = MyProcNumber;
2174 1056948 : vxid.localTransactionId = GetNextLocalTransactionId();
2175 :
2176 : /*
2177 : * Lock the virtual transaction id before we announce it in the proc array
2178 : */
2179 1056948 : VirtualXactLockTableInsert(vxid);
2180 :
2181 : /*
2182 : * Advertise it in the proc array. We assume assignment of
2183 : * localTransactionId is atomic, and the proc number should be set
2184 : * already.
2185 : */
2186 : Assert(MyProc->vxid.procNumber == vxid.procNumber);
2187 1056948 : MyProc->vxid.lxid = vxid.localTransactionId;
2188 :
2189 : TRACE_POSTGRESQL_TRANSACTION_START(vxid.localTransactionId);
2190 :
2191 : /*
2192 : * set transaction_timestamp() (a/k/a now()). Normally, we want this to
2193 : * be the same as the first command's statement_timestamp(), so don't do a
2194 : * fresh GetCurrentTimestamp() call (which'd be expensive anyway). But
2195 : * for transactions started inside procedures (i.e., nonatomic SPI
2196 : * contexts), we do need to advance the timestamp. Also, in a parallel
2197 : * worker, the timestamp should already have been provided by a call to
2198 : * SetParallelStartTimestamps().
2199 : */
2200 1056948 : if (!IsParallelWorker())
2201 : {
2202 1048710 : if (!SPI_inside_nonatomic_context())
2203 1044278 : xactStartTimestamp = stmtStartTimestamp;
2204 : else
2205 4432 : xactStartTimestamp = GetCurrentTimestamp();
2206 : }
2207 : else
2208 : Assert(xactStartTimestamp != 0);
2209 1056948 : pgstat_report_xact_timestamp(xactStartTimestamp);
2210 : /* Mark xactStopTimestamp as unset. */
2211 1056948 : xactStopTimestamp = 0;
2212 :
2213 : /*
2214 : * initialize other subsystems for new transaction
2215 : */
2216 1056948 : AtStart_GUC();
2217 1056948 : AtStart_Cache();
2218 1056948 : AfterTriggerBeginXact();
2219 :
2220 : /*
2221 : * done with start processing, set current transaction state to "in
2222 : * progress"
2223 : */
2224 1056948 : s->state = TRANS_INPROGRESS;
2225 :
2226 : /* Schedule transaction timeout */
2227 1056948 : if (TransactionTimeout > 0)
2228 2 : enable_timeout_after(TRANSACTION_TIMEOUT, TransactionTimeout);
2229 :
2230 1056948 : ShowTransactionState("StartTransaction");
2231 1056948 : }
2232 :
2233 :
2234 : /*
2235 : * CommitTransaction
2236 : *
2237 : * NB: if you change this routine, better look at PrepareTransaction too!
2238 : */
2239 : static void
2240 1007522 : CommitTransaction(void)
2241 : {
2242 1007522 : TransactionState s = CurrentTransactionState;
2243 : TransactionId latestXid;
2244 : bool is_parallel_worker;
2245 :
2246 1007522 : is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);
2247 :
2248 : /* Enforce parallel mode restrictions during parallel worker commit. */
2249 1007522 : if (is_parallel_worker)
2250 2734 : EnterParallelMode();
2251 :
2252 1007522 : ShowTransactionState("CommitTransaction");
2253 :
2254 : /*
2255 : * check the current transaction state
2256 : */
2257 1007522 : if (s->state != TRANS_INPROGRESS)
2258 0 : elog(WARNING, "CommitTransaction while in %s state",
2259 : TransStateAsString(s->state));
2260 : Assert(s->parent == NULL);
2261 :
2262 : /*
2263 : * Do pre-commit processing that involves calling user-defined code, such
2264 : * as triggers. SECURITY_RESTRICTED_OPERATION contexts must not queue an
2265 : * action that would run here, because that would bypass the sandbox.
2266 : * Since closing cursors could queue trigger actions, triggers could open
2267 : * cursors, etc, we have to keep looping until there's nothing left to do.
2268 : */
2269 : for (;;)
2270 : {
2271 : /*
2272 : * Fire all currently pending deferred triggers.
2273 : */
2274 1018606 : AfterTriggerFireDeferred();
2275 :
2276 : /*
2277 : * Close open portals (converting holdable ones into static portals).
2278 : * If there weren't any, we are done ... otherwise loop back to check
2279 : * if they queued deferred triggers. Lather, rinse, repeat.
2280 : */
2281 1018452 : if (!PreCommit_Portals(false))
2282 1007368 : break;
2283 : }
2284 :
2285 : /*
2286 : * The remaining actions cannot call any user-defined code, so it's safe
2287 : * to start shutting down within-transaction services. But note that most
2288 : * of this stuff could still throw an error, which would switch us into
2289 : * the transaction-abort path.
2290 : */
2291 :
2292 1007368 : CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_PRE_COMMIT
2293 : : XACT_EVENT_PRE_COMMIT);
2294 :
2295 : /*
2296 : * If this xact has started any unfinished parallel operation, clean up
2297 : * its workers, warning about leaked resources. (But we don't actually
2298 : * reset parallelModeLevel till entering TRANS_COMMIT, a bit below. This
2299 : * keeps parallel mode restrictions active as long as possible in a
2300 : * parallel worker.)
2301 : */
2302 1007368 : AtEOXact_Parallel(true);
2303 1007368 : if (is_parallel_worker)
2304 : {
2305 2734 : if (s->parallelModeLevel != 1)
2306 0 : elog(WARNING, "parallelModeLevel is %d not 1 at end of parallel worker transaction",
2307 : s->parallelModeLevel);
2308 : }
2309 : else
2310 : {
2311 1004634 : if (s->parallelModeLevel != 0)
2312 0 : elog(WARNING, "parallelModeLevel is %d not 0 at end of transaction",
2313 : s->parallelModeLevel);
2314 : }
2315 :
2316 : /* Shut down the deferred-trigger manager */
2317 1007368 : AfterTriggerEndXact(true);
2318 :
2319 : /*
2320 : * Let ON COMMIT management do its thing (must happen after closing
2321 : * cursors, to avoid dangling-reference problems)
2322 : */
2323 1007368 : PreCommit_on_commit_actions();
2324 :
2325 : /*
2326 : * Synchronize files that are created and not WAL-logged during this
2327 : * transaction. This must happen before AtEOXact_RelationMap(), so that we
2328 : * don't see committed-but-broken files after a crash.
2329 : */
2330 1007362 : smgrDoPendingSyncs(true, is_parallel_worker);
2331 :
2332 : /* close large objects before lower-level cleanup */
2333 1007362 : AtEOXact_LargeObject(true);
2334 :
2335 : /*
2336 : * Insert notifications sent by NOTIFY commands into the queue. This
2337 : * should be late in the pre-commit sequence to minimize time spent
2338 : * holding the notify-insertion lock. However, this could result in
2339 : * creating a snapshot, so we must do it before serializable cleanup.
2340 : */
2341 1007362 : PreCommit_Notify();
2342 :
2343 : /*
2344 : * Mark serializable transaction as complete for predicate locking
2345 : * purposes. This should be done as late as we can put it and still allow
2346 : * errors to be raised for failure patterns found at commit. This is not
2347 : * appropriate in a parallel worker however, because we aren't committing
2348 : * the leader's transaction and its serializable state will live on.
2349 : */
2350 1007362 : if (!is_parallel_worker)
2351 1004628 : PreCommit_CheckForSerializationFailure();
2352 :
2353 : /* Prevent cancel/die interrupt while cleaning up */
2354 1007052 : HOLD_INTERRUPTS();
2355 :
2356 : /* Commit updates to the relation map --- do this as late as possible */
2357 1007052 : AtEOXact_RelationMap(true, is_parallel_worker);
2358 :
2359 : /*
2360 : * set the current transaction state information appropriately during
2361 : * commit processing
2362 : */
2363 1007052 : s->state = TRANS_COMMIT;
2364 1007052 : s->parallelModeLevel = 0;
2365 1007052 : s->parallelChildXact = false; /* should be false already */
2366 :
2367 : /* Disable transaction timeout */
2368 1007052 : if (TransactionTimeout > 0)
2369 2 : disable_timeout(TRANSACTION_TIMEOUT, false);
2370 :
2371 1007052 : if (!is_parallel_worker)
2372 : {
2373 : /*
2374 : * We need to mark our XIDs as committed in pg_xact. This is where we
2375 : * durably commit.
2376 : */
2377 1004318 : latestXid = RecordTransactionCommit();
2378 : }
2379 : else
2380 : {
2381 : /*
2382 : * We must not mark our XID committed; the parallel leader is
2383 : * responsible for that.
2384 : */
2385 2734 : latestXid = InvalidTransactionId;
2386 :
2387 : /*
2388 : * Make sure the leader will know about any WAL we wrote before it
2389 : * commits.
2390 : */
2391 2734 : ParallelWorkerReportLastRecEnd(XactLastRecEnd);
2392 : }
2393 :
2394 : TRACE_POSTGRESQL_TRANSACTION_COMMIT(MyProc->vxid.lxid);
2395 :
2396 : /*
2397 : * Let others know about no transaction in progress by me. Note that this
2398 : * must be done _before_ releasing locks we hold and _after_
2399 : * RecordTransactionCommit.
2400 : */
2401 1007052 : ProcArrayEndTransaction(MyProc, latestXid);
2402 :
2403 : /*
2404 : * This is all post-commit cleanup. Note that if an error is raised here,
2405 : * it's too late to abort the transaction. This should be just
2406 : * noncritical resource releasing.
2407 : *
2408 : * The ordering of operations is not entirely random. The idea is:
2409 : * release resources visible to other backends (eg, files, buffer pins);
2410 : * then release locks; then release backend-local resources. We want to
2411 : * release locks at the point where any backend waiting for us will see
2412 : * our transaction as being fully cleaned up.
2413 : *
2414 : * Resources that can be associated with individual queries are handled by
2415 : * the ResourceOwner mechanism. The other calls here are for backend-wide
2416 : * state.
2417 : */
2418 :
2419 1007052 : CallXactCallbacks(is_parallel_worker ? XACT_EVENT_PARALLEL_COMMIT
2420 : : XACT_EVENT_COMMIT);
2421 :
2422 1007052 : CurrentResourceOwner = NULL;
2423 1007052 : ResourceOwnerRelease(TopTransactionResourceOwner,
2424 : RESOURCE_RELEASE_BEFORE_LOCKS,
2425 : true, true);
2426 :
2427 1007052 : AtEOXact_Aio(true);
2428 :
2429 : /* Check we've released all buffer pins */
2430 1007052 : AtEOXact_Buffers(true);
2431 :
2432 : /* Clean up the relation cache */
2433 1007052 : AtEOXact_RelationCache(true);
2434 :
2435 : /* Clean up the type cache */
2436 1007052 : AtEOXact_TypeCache();
2437 :
2438 : /*
2439 : * Make catalog changes visible to all backends. This has to happen after
2440 : * relcache references are dropped (see comments for
2441 : * AtEOXact_RelationCache), but before locks are released (if anyone is
2442 : * waiting for lock on a relation we've modified, we want them to know
2443 : * about the catalog change before they start using the relation).
2444 : */
2445 1007052 : AtEOXact_Inval(true);
2446 :
2447 1007052 : AtEOXact_MultiXact();
2448 :
2449 1007052 : ResourceOwnerRelease(TopTransactionResourceOwner,
2450 : RESOURCE_RELEASE_LOCKS,
2451 : true, true);
2452 1007052 : ResourceOwnerRelease(TopTransactionResourceOwner,
2453 : RESOURCE_RELEASE_AFTER_LOCKS,
2454 : true, true);
2455 :
2456 : /*
2457 : * Likewise, dropping of files deleted during the transaction is best done
2458 : * after releasing relcache and buffer pins. (This is not strictly
2459 : * necessary during commit, since such pins should have been released
2460 : * already, but this ordering is definitely critical during abort.) Since
2461 : * this may take many seconds, also delay until after releasing locks.
2462 : * Other backends will observe the attendant catalog changes and not
2463 : * attempt to access affected files.
2464 : */
2465 1007052 : smgrDoPendingDeletes(true);
2466 :
2467 : /*
2468 : * Send out notification signals to other backends (and do other
2469 : * post-commit NOTIFY cleanup). This must not happen until after our
2470 : * transaction is fully done from the viewpoint of other backends.
2471 : */
2472 1007052 : AtCommit_Notify();
2473 :
2474 : /*
2475 : * Everything after this should be purely internal-to-this-backend
2476 : * cleanup.
2477 : */
2478 1007052 : AtEOXact_GUC(true, 1);
2479 1007052 : AtEOXact_SPI(true);
2480 1007052 : AtEOXact_Enum();
2481 1007052 : AtEOXact_on_commit_actions(true);
2482 1007052 : AtEOXact_Namespace(true, is_parallel_worker);
2483 1007052 : AtEOXact_SMgr();
2484 1007052 : AtEOXact_Files(true);
2485 1007052 : AtEOXact_ComboCid();
2486 1007052 : AtEOXact_HashTables(true);
2487 1007052 : AtEOXact_PgStat(true, is_parallel_worker);
2488 1007052 : AtEOXact_Snapshot(true, false);
2489 1007052 : AtEOXact_ApplyLauncher(true);
2490 1007052 : AtEOXact_LogicalRepWorkers(true);
2491 1007052 : pgstat_report_xact_timestamp(0);
2492 :
2493 1007052 : ResourceOwnerDelete(TopTransactionResourceOwner);
2494 1007052 : s->curTransactionOwner = NULL;
2495 1007052 : CurTransactionResourceOwner = NULL;
2496 1007052 : TopTransactionResourceOwner = NULL;
2497 :
2498 1007052 : AtCommit_Memory();
2499 :
2500 1007052 : s->fullTransactionId = InvalidFullTransactionId;
2501 1007052 : s->subTransactionId = InvalidSubTransactionId;
2502 1007052 : s->nestingLevel = 0;
2503 1007052 : s->gucNestLevel = 0;
2504 1007052 : s->childXids = NULL;
2505 1007052 : s->nChildXids = 0;
2506 1007052 : s->maxChildXids = 0;
2507 :
2508 1007052 : XactTopFullTransactionId = InvalidFullTransactionId;
2509 1007052 : nParallelCurrentXids = 0;
2510 :
2511 : /*
2512 : * done with commit processing, set current transaction state back to
2513 : * default
2514 : */
2515 1007052 : s->state = TRANS_DEFAULT;
2516 :
2517 1007052 : RESUME_INTERRUPTS();
2518 1007052 : }
2519 :
2520 :
2521 : /*
2522 : * PrepareTransaction
2523 : *
2524 : * NB: if you change this routine, better look at CommitTransaction too!
2525 : */
2526 : static void
2527 668 : PrepareTransaction(void)
2528 : {
2529 668 : TransactionState s = CurrentTransactionState;
2530 668 : FullTransactionId fxid = GetCurrentFullTransactionId();
2531 : GlobalTransaction gxact;
2532 : TimestampTz prepared_at;
2533 :
2534 : Assert(!IsInParallelMode());
2535 :
2536 668 : ShowTransactionState("PrepareTransaction");
2537 :
2538 : /*
2539 : * check the current transaction state
2540 : */
2541 668 : if (s->state != TRANS_INPROGRESS)
2542 0 : elog(WARNING, "PrepareTransaction while in %s state",
2543 : TransStateAsString(s->state));
2544 : Assert(s->parent == NULL);
2545 :
2546 : /*
2547 : * Do pre-commit processing that involves calling user-defined code, such
2548 : * as triggers. Since closing cursors could queue trigger actions,
2549 : * triggers could open cursors, etc, we have to keep looping until there's
2550 : * nothing left to do.
2551 : */
2552 : for (;;)
2553 : {
2554 : /*
2555 : * Fire all currently pending deferred triggers.
2556 : */
2557 674 : AfterTriggerFireDeferred();
2558 :
2559 : /*
2560 : * Close open portals (converting holdable ones into static portals).
2561 : * If there weren't any, we are done ... otherwise loop back to check
2562 : * if they queued deferred triggers. Lather, rinse, repeat.
2563 : */
2564 674 : if (!PreCommit_Portals(true))
2565 668 : break;
2566 : }
2567 :
2568 668 : CallXactCallbacks(XACT_EVENT_PRE_PREPARE);
2569 :
2570 : /*
2571 : * The remaining actions cannot call any user-defined code, so it's safe
2572 : * to start shutting down within-transaction services. But note that most
2573 : * of this stuff could still throw an error, which would switch us into
2574 : * the transaction-abort path.
2575 : */
2576 :
2577 : /* Shut down the deferred-trigger manager */
2578 666 : AfterTriggerEndXact(true);
2579 :
2580 : /*
2581 : * Let ON COMMIT management do its thing (must happen after closing
2582 : * cursors, to avoid dangling-reference problems)
2583 : */
2584 666 : PreCommit_on_commit_actions();
2585 :
2586 : /*
2587 : * Synchronize files that are created and not WAL-logged during this
2588 : * transaction. This must happen before EndPrepare(), so that we don't see
2589 : * committed-but-broken files after a crash and COMMIT PREPARED.
2590 : */
2591 666 : smgrDoPendingSyncs(true, false);
2592 :
2593 : /* close large objects before lower-level cleanup */
2594 666 : AtEOXact_LargeObject(true);
2595 :
2596 : /* NOTIFY requires no work at this point */
2597 :
2598 : /*
2599 : * Mark serializable transaction as complete for predicate locking
2600 : * purposes. This should be done as late as we can put it and still allow
2601 : * errors to be raised for failure patterns found at commit.
2602 : */
2603 666 : PreCommit_CheckForSerializationFailure();
2604 :
2605 : /*
2606 : * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
2607 : * this transaction. Having the prepared xact hold locks on another
2608 : * backend's temp table seems a bad idea --- for instance it would prevent
2609 : * the backend from exiting. There are other problems too, such as how to
2610 : * clean up the source backend's local buffers and ON COMMIT state if the
2611 : * prepared xact includes a DROP of a temp table.
2612 : *
2613 : * Other objects types, like functions, operators or extensions, share the
2614 : * same restriction as they should not be created, locked or dropped as
2615 : * this can mess up with this session or even a follow-up session trying
2616 : * to use the same temporary namespace.
2617 : *
2618 : * We must check this after executing any ON COMMIT actions, because they
2619 : * might still access a temp relation.
2620 : *
2621 : * XXX In principle this could be relaxed to allow some useful special
2622 : * cases, such as a temp table created and dropped all within the
2623 : * transaction. That seems to require much more bookkeeping though.
2624 : */
2625 666 : if ((MyXactFlags & XACT_FLAGS_ACCESSEDTEMPNAMESPACE))
2626 68 : ereport(ERROR,
2627 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2628 : errmsg("cannot PREPARE a transaction that has operated on temporary objects")));
2629 :
2630 : /*
2631 : * Likewise, don't allow PREPARE after pg_export_snapshot. This could be
2632 : * supported if we added cleanup logic to twophase.c, but for now it
2633 : * doesn't seem worth the trouble.
2634 : */
2635 598 : if (XactHasExportedSnapshots())
2636 0 : ereport(ERROR,
2637 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2638 : errmsg("cannot PREPARE a transaction that has exported snapshots")));
2639 :
2640 : /* Prevent cancel/die interrupt while cleaning up */
2641 598 : HOLD_INTERRUPTS();
2642 :
2643 : /*
2644 : * set the current transaction state information appropriately during
2645 : * prepare processing
2646 : */
2647 598 : s->state = TRANS_PREPARE;
2648 :
2649 : /* Disable transaction timeout */
2650 598 : if (TransactionTimeout > 0)
2651 0 : disable_timeout(TRANSACTION_TIMEOUT, false);
2652 :
2653 598 : prepared_at = GetCurrentTimestamp();
2654 :
2655 : /*
2656 : * Reserve the GID for this transaction. This could fail if the requested
2657 : * GID is invalid or already in use.
2658 : */
2659 598 : gxact = MarkAsPreparing(fxid, prepareGID, prepared_at,
2660 : GetUserId(), MyDatabaseId);
2661 574 : prepareGID = NULL;
2662 :
2663 : /*
2664 : * Collect data for the 2PC state file. Note that in general, no actual
2665 : * state change should happen in the called modules during this step,
2666 : * since it's still possible to fail before commit, and in that case we
2667 : * want transaction abort to be able to clean up. (In particular, the
2668 : * AtPrepare routines may error out if they find cases they cannot
2669 : * handle.) State cleanup should happen in the PostPrepare routines
2670 : * below. However, some modules can go ahead and clear state here because
2671 : * they wouldn't do anything with it during abort anyway.
2672 : *
2673 : * Note: because the 2PC state file records will be replayed in the same
2674 : * order they are made, the order of these calls has to match the order in
2675 : * which we want things to happen during COMMIT PREPARED or ROLLBACK
2676 : * PREPARED; in particular, pay attention to whether things should happen
2677 : * before or after releasing the transaction's locks.
2678 : */
2679 574 : StartPrepare(gxact);
2680 :
2681 574 : AtPrepare_Notify();
2682 574 : AtPrepare_Locks();
2683 570 : AtPrepare_PredicateLocks();
2684 570 : AtPrepare_PgStat();
2685 570 : AtPrepare_MultiXact();
2686 570 : AtPrepare_RelationMap();
2687 :
2688 : /*
2689 : * Here is where we really truly prepare.
2690 : *
2691 : * We have to record transaction prepares even if we didn't make any
2692 : * updates, because the transaction manager might get confused if we lose
2693 : * a global transaction.
2694 : */
2695 570 : EndPrepare(gxact);
2696 :
2697 : /*
2698 : * Now we clean up backend-internal state and release internal resources.
2699 : */
2700 :
2701 : /* Reset XactLastRecEnd until the next transaction writes something */
2702 570 : XactLastRecEnd = 0;
2703 :
2704 : /*
2705 : * Transfer our locks to a dummy PGPROC. This has to be done before
2706 : * ProcArrayClearTransaction(). Otherwise, a GetLockConflicts() would
2707 : * conclude "xact already committed or aborted" for our locks.
2708 : */
2709 570 : PostPrepare_Locks(fxid);
2710 :
2711 : /*
2712 : * Let others know about no transaction in progress by me. This has to be
2713 : * done *after* the prepared transaction has been marked valid, else
2714 : * someone may think it is unlocked and recyclable.
2715 : */
2716 570 : ProcArrayClearTransaction(MyProc);
2717 :
2718 : /*
2719 : * In normal commit-processing, this is all non-critical post-transaction
2720 : * cleanup. When the transaction is prepared, however, it's important
2721 : * that the locks and other per-backend resources are transferred to the
2722 : * prepared transaction's PGPROC entry. Note that if an error is raised
2723 : * here, it's too late to abort the transaction. XXX: This probably should
2724 : * be in a critical section, to force a PANIC if any of this fails, but
2725 : * that cure could be worse than the disease.
2726 : */
2727 :
2728 570 : CallXactCallbacks(XACT_EVENT_PREPARE);
2729 :
2730 570 : ResourceOwnerRelease(TopTransactionResourceOwner,
2731 : RESOURCE_RELEASE_BEFORE_LOCKS,
2732 : true, true);
2733 :
2734 570 : AtEOXact_Aio(true);
2735 :
2736 : /* Check we've released all buffer pins */
2737 570 : AtEOXact_Buffers(true);
2738 :
2739 : /* Clean up the relation cache */
2740 570 : AtEOXact_RelationCache(true);
2741 :
2742 : /* Clean up the type cache */
2743 570 : AtEOXact_TypeCache();
2744 :
2745 : /* notify doesn't need a postprepare call */
2746 :
2747 570 : PostPrepare_PgStat();
2748 :
2749 570 : PostPrepare_Inval();
2750 :
2751 570 : PostPrepare_smgr();
2752 :
2753 570 : PostPrepare_MultiXact(fxid);
2754 :
2755 570 : PostPrepare_PredicateLocks(fxid);
2756 :
2757 570 : ResourceOwnerRelease(TopTransactionResourceOwner,
2758 : RESOURCE_RELEASE_LOCKS,
2759 : true, true);
2760 570 : ResourceOwnerRelease(TopTransactionResourceOwner,
2761 : RESOURCE_RELEASE_AFTER_LOCKS,
2762 : true, true);
2763 :
2764 : /*
2765 : * Allow another backend to finish the transaction. After
2766 : * PostPrepare_Twophase(), the transaction is completely detached from our
2767 : * backend. The rest is just non-critical cleanup of backend-local state.
2768 : */
2769 570 : PostPrepare_Twophase();
2770 :
2771 : /* PREPARE acts the same as COMMIT as far as GUC is concerned */
2772 570 : AtEOXact_GUC(true, 1);
2773 570 : AtEOXact_SPI(true);
2774 570 : AtEOXact_Enum();
2775 570 : AtEOXact_on_commit_actions(true);
2776 570 : AtEOXact_Namespace(true, false);
2777 570 : AtEOXact_SMgr();
2778 570 : AtEOXact_Files(true);
2779 570 : AtEOXact_ComboCid();
2780 570 : AtEOXact_HashTables(true);
2781 : /* don't call AtEOXact_PgStat here; we fixed pgstat state above */
2782 570 : AtEOXact_Snapshot(true, true);
2783 : /* we treat PREPARE as ROLLBACK so far as waking workers goes */
2784 570 : AtEOXact_ApplyLauncher(false);
2785 570 : AtEOXact_LogicalRepWorkers(false);
2786 570 : pgstat_report_xact_timestamp(0);
2787 :
2788 570 : CurrentResourceOwner = NULL;
2789 570 : ResourceOwnerDelete(TopTransactionResourceOwner);
2790 570 : s->curTransactionOwner = NULL;
2791 570 : CurTransactionResourceOwner = NULL;
2792 570 : TopTransactionResourceOwner = NULL;
2793 :
2794 570 : AtCommit_Memory();
2795 :
2796 570 : s->fullTransactionId = InvalidFullTransactionId;
2797 570 : s->subTransactionId = InvalidSubTransactionId;
2798 570 : s->nestingLevel = 0;
2799 570 : s->gucNestLevel = 0;
2800 570 : s->childXids = NULL;
2801 570 : s->nChildXids = 0;
2802 570 : s->maxChildXids = 0;
2803 :
2804 570 : XactTopFullTransactionId = InvalidFullTransactionId;
2805 570 : nParallelCurrentXids = 0;
2806 :
2807 : /*
2808 : * done with 1st phase commit processing, set current transaction state
2809 : * back to default
2810 : */
2811 570 : s->state = TRANS_DEFAULT;
2812 :
2813 570 : RESUME_INTERRUPTS();
2814 570 : }
2815 :
2816 :
2817 : /*
2818 : * AbortTransaction
2819 : */
2820 : static void
2821 49326 : AbortTransaction(void)
2822 : {
2823 49326 : TransactionState s = CurrentTransactionState;
2824 : TransactionId latestXid;
2825 : bool is_parallel_worker;
2826 :
2827 : /* Prevent cancel/die interrupt while cleaning up */
2828 49326 : HOLD_INTERRUPTS();
2829 :
2830 : /* Disable transaction timeout */
2831 49326 : if (TransactionTimeout > 0)
2832 2 : disable_timeout(TRANSACTION_TIMEOUT, false);
2833 :
2834 : /* Make sure we have a valid memory context and resource owner */
2835 49326 : AtAbort_Memory();
2836 49326 : AtAbort_ResourceOwner();
2837 :
2838 : /*
2839 : * Release any LW locks we might be holding as quickly as possible.
2840 : * (Regular locks, however, must be held till we finish aborting.)
2841 : * Releasing LW locks is critical since we might try to grab them again
2842 : * while cleaning up!
2843 : */
2844 49326 : LWLockReleaseAll();
2845 :
2846 : /* Clear wait information and command progress indicator */
2847 49326 : pgstat_report_wait_end();
2848 49326 : pgstat_progress_end_command();
2849 :
2850 49326 : pgaio_error_cleanup();
2851 :
2852 : /* Clean up buffer content locks, too */
2853 49326 : UnlockBuffers();
2854 :
2855 : /* Reset WAL record construction state */
2856 49326 : XLogResetInsertion();
2857 :
2858 : /* Cancel condition variable sleep */
2859 49326 : ConditionVariableCancelSleep();
2860 :
2861 : /*
2862 : * Also clean up any open wait for lock, since the lock manager will choke
2863 : * if we try to wait for another lock before doing this.
2864 : */
2865 49326 : LockErrorCleanup();
2866 :
2867 : /*
2868 : * If any timeout events are still active, make sure the timeout interrupt
2869 : * is scheduled. This covers possible loss of a timeout interrupt due to
2870 : * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
2871 : * We delay this till after LockErrorCleanup so that we don't uselessly
2872 : * reschedule lock or deadlock check timeouts.
2873 : */
2874 49326 : reschedule_timeouts();
2875 :
2876 : /*
2877 : * Re-enable signals, in case we got here by longjmp'ing out of a signal
2878 : * handler. We do this fairly early in the sequence so that the timeout
2879 : * infrastructure will be functional if needed while aborting.
2880 : */
2881 49326 : sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
2882 :
2883 : /*
2884 : * check the current transaction state
2885 : */
2886 49326 : is_parallel_worker = (s->blockState == TBLOCK_PARALLEL_INPROGRESS);
2887 49326 : if (s->state != TRANS_INPROGRESS && s->state != TRANS_PREPARE)
2888 0 : elog(WARNING, "AbortTransaction while in %s state",
2889 : TransStateAsString(s->state));
2890 : Assert(s->parent == NULL);
2891 :
2892 : /*
2893 : * set the current transaction state information appropriately during the
2894 : * abort processing
2895 : */
2896 49326 : s->state = TRANS_ABORT;
2897 :
2898 : /*
2899 : * Reset user ID which might have been changed transiently. We need this
2900 : * to clean up in case control escaped out of a SECURITY DEFINER function
2901 : * or other local change of CurrentUserId; therefore, the prior value of
2902 : * SecurityRestrictionContext also needs to be restored.
2903 : *
2904 : * (Note: it is not necessary to restore session authorization or role
2905 : * settings here because those can only be changed via GUC, and GUC will
2906 : * take care of rolling them back if need be.)
2907 : */
2908 49326 : SetUserIdAndSecContext(s->prevUser, s->prevSecContext);
2909 :
2910 : /* Forget about any active REINDEX. */
2911 49326 : ResetReindexState(s->nestingLevel);
2912 :
2913 : /* Reset logical streaming state. */
2914 49326 : ResetLogicalStreamingState();
2915 :
2916 : /* Reset snapshot export state. */
2917 49326 : SnapBuildResetExportedSnapshotState();
2918 :
2919 : /*
2920 : * If this xact has started any unfinished parallel operation, clean up
2921 : * its workers and exit parallel mode. Don't warn about leaked resources.
2922 : */
2923 49326 : AtEOXact_Parallel(false);
2924 49326 : s->parallelModeLevel = 0;
2925 49326 : s->parallelChildXact = false; /* should be false already */
2926 :
2927 : /*
2928 : * do abort processing
2929 : */
2930 49326 : AfterTriggerEndXact(false); /* 'false' means it's abort */
2931 49326 : AtAbort_Portals();
2932 49326 : smgrDoPendingSyncs(false, is_parallel_worker);
2933 49326 : AtEOXact_LargeObject(false);
2934 49326 : AtAbort_Notify();
2935 49326 : AtEOXact_RelationMap(false, is_parallel_worker);
2936 49326 : AtAbort_Twophase();
2937 :
2938 : /*
2939 : * Advertise the fact that we aborted in pg_xact (assuming that we got as
2940 : * far as assigning an XID to advertise). But if we're inside a parallel
2941 : * worker, skip this; the user backend must be the one to write the abort
2942 : * record.
2943 : */
2944 49326 : if (!is_parallel_worker)
2945 49314 : latestXid = RecordTransactionAbort(false);
2946 : else
2947 : {
2948 12 : latestXid = InvalidTransactionId;
2949 :
2950 : /*
2951 : * Since the parallel leader won't get our value of XactLastRecEnd in
2952 : * this case, we nudge WAL-writer ourselves in this case. See related
2953 : * comments in RecordTransactionAbort for why this matters.
2954 : */
2955 12 : XLogSetAsyncXactLSN(XactLastRecEnd);
2956 : }
2957 :
2958 : TRACE_POSTGRESQL_TRANSACTION_ABORT(MyProc->vxid.lxid);
2959 :
2960 : /*
2961 : * Let others know about no transaction in progress by me. Note that this
2962 : * must be done _before_ releasing locks we hold and _after_
2963 : * RecordTransactionAbort.
2964 : */
2965 49326 : ProcArrayEndTransaction(MyProc, latestXid);
2966 :
2967 : /*
2968 : * Post-abort cleanup. See notes in CommitTransaction() concerning
2969 : * ordering. We can skip all of it if the transaction failed before
2970 : * creating a resource owner.
2971 : */
2972 49326 : if (TopTransactionResourceOwner != NULL)
2973 : {
2974 49326 : if (is_parallel_worker)
2975 12 : CallXactCallbacks(XACT_EVENT_PARALLEL_ABORT);
2976 : else
2977 49314 : CallXactCallbacks(XACT_EVENT_ABORT);
2978 :
2979 49326 : ResourceOwnerRelease(TopTransactionResourceOwner,
2980 : RESOURCE_RELEASE_BEFORE_LOCKS,
2981 : false, true);
2982 49326 : AtEOXact_Aio(false);
2983 49326 : AtEOXact_Buffers(false);
2984 49326 : AtEOXact_RelationCache(false);
2985 49326 : AtEOXact_TypeCache();
2986 49326 : AtEOXact_Inval(false);
2987 49326 : AtEOXact_MultiXact();
2988 49326 : ResourceOwnerRelease(TopTransactionResourceOwner,
2989 : RESOURCE_RELEASE_LOCKS,
2990 : false, true);
2991 49326 : ResourceOwnerRelease(TopTransactionResourceOwner,
2992 : RESOURCE_RELEASE_AFTER_LOCKS,
2993 : false, true);
2994 49326 : smgrDoPendingDeletes(false);
2995 :
2996 49326 : AtEOXact_GUC(false, 1);
2997 49326 : AtEOXact_SPI(false);
2998 49326 : AtEOXact_Enum();
2999 49326 : AtEOXact_on_commit_actions(false);
3000 49326 : AtEOXact_Namespace(false, is_parallel_worker);
3001 49326 : AtEOXact_SMgr();
3002 49326 : AtEOXact_Files(false);
3003 49326 : AtEOXact_ComboCid();
3004 49326 : AtEOXact_HashTables(false);
3005 49326 : AtEOXact_PgStat(false, is_parallel_worker);
3006 49326 : AtEOXact_ApplyLauncher(false);
3007 49326 : AtEOXact_LogicalRepWorkers(false);
3008 49326 : pgstat_report_xact_timestamp(0);
3009 : }
3010 :
3011 : /*
3012 : * State remains TRANS_ABORT until CleanupTransaction().
3013 : */
3014 49326 : RESUME_INTERRUPTS();
3015 49326 : }
3016 :
3017 : /*
3018 : * CleanupTransaction
3019 : */
3020 : static void
3021 49326 : CleanupTransaction(void)
3022 : {
3023 49326 : TransactionState s = CurrentTransactionState;
3024 :
3025 : /*
3026 : * State should still be TRANS_ABORT from AbortTransaction().
3027 : */
3028 49326 : if (s->state != TRANS_ABORT)
3029 0 : elog(FATAL, "CleanupTransaction: unexpected state %s",
3030 : TransStateAsString(s->state));
3031 :
3032 : /*
3033 : * do abort cleanup processing
3034 : */
3035 49326 : AtCleanup_Portals(); /* now safe to release portal memory */
3036 49326 : AtEOXact_Snapshot(false, true); /* and release the transaction's snapshots */
3037 :
3038 49326 : CurrentResourceOwner = NULL; /* and resource owner */
3039 49326 : if (TopTransactionResourceOwner)
3040 49326 : ResourceOwnerDelete(TopTransactionResourceOwner);
3041 49326 : s->curTransactionOwner = NULL;
3042 49326 : CurTransactionResourceOwner = NULL;
3043 49326 : TopTransactionResourceOwner = NULL;
3044 :
3045 49326 : AtCleanup_Memory(); /* and transaction memory */
3046 :
3047 49326 : s->fullTransactionId = InvalidFullTransactionId;
3048 49326 : s->subTransactionId = InvalidSubTransactionId;
3049 49326 : s->nestingLevel = 0;
3050 49326 : s->gucNestLevel = 0;
3051 49326 : s->childXids = NULL;
3052 49326 : s->nChildXids = 0;
3053 49326 : s->maxChildXids = 0;
3054 49326 : s->parallelModeLevel = 0;
3055 49326 : s->parallelChildXact = false;
3056 :
3057 49326 : XactTopFullTransactionId = InvalidFullTransactionId;
3058 49326 : nParallelCurrentXids = 0;
3059 :
3060 : /*
3061 : * done with abort processing, set current transaction state back to
3062 : * default
3063 : */
3064 49326 : s->state = TRANS_DEFAULT;
3065 49326 : }
3066 :
3067 : /*
3068 : * StartTransactionCommand
3069 : */
3070 : void
3071 1241300 : StartTransactionCommand(void)
3072 : {
3073 1241300 : TransactionState s = CurrentTransactionState;
3074 :
3075 1241300 : switch (s->blockState)
3076 : {
3077 : /*
3078 : * if we aren't in a transaction block, we just do our usual start
3079 : * transaction.
3080 : */
3081 1054142 : case TBLOCK_DEFAULT:
3082 1054142 : StartTransaction();
3083 1054142 : s->blockState = TBLOCK_STARTED;
3084 1054142 : break;
3085 :
3086 : /*
3087 : * We are somewhere in a transaction block or subtransaction and
3088 : * about to start a new command. For now we do nothing, but
3089 : * someday we may do command-local resource initialization. (Note
3090 : * that any needed CommandCounterIncrement was done by the
3091 : * previous CommitTransactionCommand.)
3092 : */
3093 185384 : case TBLOCK_INPROGRESS:
3094 : case TBLOCK_IMPLICIT_INPROGRESS:
3095 : case TBLOCK_SUBINPROGRESS:
3096 185384 : break;
3097 :
3098 : /*
3099 : * Here we are in a failed transaction block (one of the commands
3100 : * caused an abort) so we do nothing but remain in the abort
3101 : * state. Eventually we will get a ROLLBACK command which will
3102 : * get us out of this state. (It is up to other code to ensure
3103 : * that no commands other than ROLLBACK will be processed in these
3104 : * states.)
3105 : */
3106 1774 : case TBLOCK_ABORT:
3107 : case TBLOCK_SUBABORT:
3108 1774 : break;
3109 :
3110 : /* These cases are invalid. */
3111 0 : case TBLOCK_STARTED:
3112 : case TBLOCK_BEGIN:
3113 : case TBLOCK_PARALLEL_INPROGRESS:
3114 : case TBLOCK_SUBBEGIN:
3115 : case TBLOCK_END:
3116 : case TBLOCK_SUBRELEASE:
3117 : case TBLOCK_SUBCOMMIT:
3118 : case TBLOCK_ABORT_END:
3119 : case TBLOCK_SUBABORT_END:
3120 : case TBLOCK_ABORT_PENDING:
3121 : case TBLOCK_SUBABORT_PENDING:
3122 : case TBLOCK_SUBRESTART:
3123 : case TBLOCK_SUBABORT_RESTART:
3124 : case TBLOCK_PREPARE:
3125 0 : elog(ERROR, "StartTransactionCommand: unexpected state %s",
3126 : BlockStateAsString(s->blockState));
3127 : break;
3128 : }
3129 :
3130 : /*
3131 : * We must switch to CurTransactionContext before returning. This is
3132 : * already done if we called StartTransaction, otherwise not.
3133 : */
3134 : Assert(CurTransactionContext != NULL);
3135 1241300 : MemoryContextSwitchTo(CurTransactionContext);
3136 1241300 : }
3137 :
3138 :
3139 : /*
3140 : * Simple system for saving and restoring transaction characteristics
3141 : * (isolation level, read only, deferrable). We need this for transaction
3142 : * chaining, so that we can set the characteristics of the new transaction to
3143 : * be the same as the previous one. (We need something like this because the
3144 : * GUC system resets the characteristics at transaction end, so for example
3145 : * just skipping the reset in StartTransaction() won't work.)
3146 : */
3147 : void
3148 1195616 : SaveTransactionCharacteristics(SavedTransactionCharacteristics *s)
3149 : {
3150 1195616 : s->save_XactIsoLevel = XactIsoLevel;
3151 1195616 : s->save_XactReadOnly = XactReadOnly;
3152 1195616 : s->save_XactDeferrable = XactDeferrable;
3153 1195616 : }
3154 :
3155 : void
3156 68 : RestoreTransactionCharacteristics(const SavedTransactionCharacteristics *s)
3157 : {
3158 68 : XactIsoLevel = s->save_XactIsoLevel;
3159 68 : XactReadOnly = s->save_XactReadOnly;
3160 68 : XactDeferrable = s->save_XactDeferrable;
3161 68 : }
3162 :
3163 : /*
3164 : * CommitTransactionCommand -- a wrapper function handling the
3165 : * loop over subtransactions to avoid a potentially dangerous recursion
3166 : * in CommitTransactionCommandInternal().
3167 : */
3168 : void
3169 1195174 : CommitTransactionCommand(void)
3170 : {
3171 : /*
3172 : * Repeatedly call CommitTransactionCommandInternal() until all the work
3173 : * is done.
3174 : */
3175 1195608 : while (!CommitTransactionCommandInternal())
3176 : {
3177 : }
3178 1194606 : }
3179 :
3180 : /*
3181 : * CommitTransactionCommandInternal - a function doing an iteration of work
3182 : * regarding handling the commit transaction command. In the case of
3183 : * subtransactions more than one iterations could be required. Returns
3184 : * true when no more iterations required, false otherwise.
3185 : */
3186 : static bool
3187 1195608 : CommitTransactionCommandInternal(void)
3188 : {
3189 1195608 : TransactionState s = CurrentTransactionState;
3190 : SavedTransactionCharacteristics savetc;
3191 :
3192 : /* Must save in case we need to restore below */
3193 1195608 : SaveTransactionCharacteristics(&savetc);
3194 :
3195 1195608 : switch (s->blockState)
3196 : {
3197 : /*
3198 : * These shouldn't happen. TBLOCK_DEFAULT means the previous
3199 : * StartTransactionCommand didn't set the STARTED state
3200 : * appropriately, while TBLOCK_PARALLEL_INPROGRESS should be ended
3201 : * by EndParallelWorkerTransaction(), not this function.
3202 : */
3203 0 : case TBLOCK_DEFAULT:
3204 : case TBLOCK_PARALLEL_INPROGRESS:
3205 0 : elog(FATAL, "CommitTransactionCommand: unexpected state %s",
3206 : BlockStateAsString(s->blockState));
3207 : break;
3208 :
3209 : /*
3210 : * If we aren't in a transaction block, just do our usual
3211 : * transaction commit, and return to the idle state.
3212 : */
3213 991956 : case TBLOCK_STARTED:
3214 991956 : CommitTransaction();
3215 991936 : s->blockState = TBLOCK_DEFAULT;
3216 991936 : break;
3217 :
3218 : /*
3219 : * We are completing a "BEGIN TRANSACTION" command, so we change
3220 : * to the "transaction block in progress" state and return. (We
3221 : * assume the BEGIN did nothing to the database, so we need no
3222 : * CommandCounterIncrement.)
3223 : */
3224 17650 : case TBLOCK_BEGIN:
3225 17650 : s->blockState = TBLOCK_INPROGRESS;
3226 17650 : break;
3227 :
3228 : /*
3229 : * This is the case when we have finished executing a command
3230 : * someplace within a transaction block. We increment the command
3231 : * counter and return.
3232 : */
3233 148126 : case TBLOCK_INPROGRESS:
3234 : case TBLOCK_IMPLICIT_INPROGRESS:
3235 : case TBLOCK_SUBINPROGRESS:
3236 148126 : CommandCounterIncrement();
3237 148126 : break;
3238 :
3239 : /*
3240 : * We are completing a "COMMIT" command. Do it and return to the
3241 : * idle state.
3242 : */
3243 12098 : case TBLOCK_END:
3244 12098 : CommitTransaction();
3245 11674 : s->blockState = TBLOCK_DEFAULT;
3246 11674 : if (s->chain)
3247 : {
3248 12 : StartTransaction();
3249 12 : s->blockState = TBLOCK_INPROGRESS;
3250 12 : s->chain = false;
3251 12 : RestoreTransactionCharacteristics(&savetc);
3252 : }
3253 11674 : break;
3254 :
3255 : /*
3256 : * Here we are in the middle of a transaction block but one of the
3257 : * commands caused an abort so we do nothing but remain in the
3258 : * abort state. Eventually we will get a ROLLBACK command.
3259 : */
3260 18 : case TBLOCK_ABORT:
3261 : case TBLOCK_SUBABORT:
3262 18 : break;
3263 :
3264 : /*
3265 : * Here we were in an aborted transaction block and we just got
3266 : * the ROLLBACK command from the user, so clean up the
3267 : * already-aborted transaction and return to the idle state.
3268 : */
3269 1376 : case TBLOCK_ABORT_END:
3270 1376 : CleanupTransaction();
3271 1376 : s->blockState = TBLOCK_DEFAULT;
3272 1376 : if (s->chain)
3273 : {
3274 12 : StartTransaction();
3275 12 : s->blockState = TBLOCK_INPROGRESS;
3276 12 : s->chain = false;
3277 12 : RestoreTransactionCharacteristics(&savetc);
3278 : }
3279 1376 : break;
3280 :
3281 : /*
3282 : * Here we were in a perfectly good transaction block but the user
3283 : * told us to ROLLBACK anyway. We have to abort the transaction
3284 : * and then clean up.
3285 : */
3286 2220 : case TBLOCK_ABORT_PENDING:
3287 2220 : AbortTransaction();
3288 2220 : CleanupTransaction();
3289 2220 : s->blockState = TBLOCK_DEFAULT;
3290 2220 : if (s->chain)
3291 : {
3292 18 : StartTransaction();
3293 18 : s->blockState = TBLOCK_INPROGRESS;
3294 18 : s->chain = false;
3295 18 : RestoreTransactionCharacteristics(&savetc);
3296 : }
3297 2220 : break;
3298 :
3299 : /*
3300 : * We are completing a "PREPARE TRANSACTION" command. Do it and
3301 : * return to the idle state.
3302 : */
3303 460 : case TBLOCK_PREPARE:
3304 460 : PrepareTransaction();
3305 364 : s->blockState = TBLOCK_DEFAULT;
3306 364 : break;
3307 :
3308 : /*
3309 : * The user issued a SAVEPOINT inside a transaction block. Start a
3310 : * subtransaction. (DefineSavepoint already did PushTransaction,
3311 : * so as to have someplace to put the SUBBEGIN state.)
3312 : */
3313 19330 : case TBLOCK_SUBBEGIN:
3314 19330 : StartSubTransaction();
3315 19330 : s->blockState = TBLOCK_SUBINPROGRESS;
3316 19330 : break;
3317 :
3318 : /*
3319 : * The user issued a RELEASE command, so we end the current
3320 : * subtransaction and return to the parent transaction. The parent
3321 : * might be ended too, so repeat till we find an INPROGRESS
3322 : * transaction or subtransaction.
3323 : */
3324 448 : case TBLOCK_SUBRELEASE:
3325 : do
3326 : {
3327 448 : CommitSubTransaction();
3328 448 : s = CurrentTransactionState; /* changed by pop */
3329 448 : } while (s->blockState == TBLOCK_SUBRELEASE);
3330 :
3331 : Assert(s->blockState == TBLOCK_INPROGRESS ||
3332 : s->blockState == TBLOCK_SUBINPROGRESS);
3333 276 : break;
3334 :
3335 : /*
3336 : * The user issued a COMMIT, so we end the current subtransaction
3337 : * hierarchy and perform final commit. We do this by rolling up
3338 : * any subtransactions into their parent, which leads to O(N^2)
3339 : * operations with respect to resource owners - this isn't that
3340 : * bad until we approach a thousands of savepoints but is
3341 : * necessary for correctness should after triggers create new
3342 : * resource owners.
3343 : */
3344 1076 : case TBLOCK_SUBCOMMIT:
3345 : do
3346 : {
3347 1076 : CommitSubTransaction();
3348 1076 : s = CurrentTransactionState; /* changed by pop */
3349 1076 : } while (s->blockState == TBLOCK_SUBCOMMIT);
3350 : /* If we had a COMMIT command, finish off the main xact too */
3351 942 : if (s->blockState == TBLOCK_END)
3352 : {
3353 : Assert(s->parent == NULL);
3354 734 : CommitTransaction();
3355 708 : s->blockState = TBLOCK_DEFAULT;
3356 708 : if (s->chain)
3357 : {
3358 18 : StartTransaction();
3359 18 : s->blockState = TBLOCK_INPROGRESS;
3360 18 : s->chain = false;
3361 18 : RestoreTransactionCharacteristics(&savetc);
3362 : }
3363 : }
3364 208 : else if (s->blockState == TBLOCK_PREPARE)
3365 : {
3366 : Assert(s->parent == NULL);
3367 208 : PrepareTransaction();
3368 206 : s->blockState = TBLOCK_DEFAULT;
3369 : }
3370 : else
3371 0 : elog(ERROR, "CommitTransactionCommand: unexpected state %s",
3372 : BlockStateAsString(s->blockState));
3373 914 : break;
3374 :
3375 : /*
3376 : * The current already-failed subtransaction is ending due to a
3377 : * ROLLBACK or ROLLBACK TO command, so pop it and recursively
3378 : * examine the parent (which could be in any of several states).
3379 : * As we need to examine the parent, return false to request the
3380 : * caller to do the next iteration.
3381 : */
3382 80 : case TBLOCK_SUBABORT_END:
3383 80 : CleanupSubTransaction();
3384 80 : return false;
3385 :
3386 : /*
3387 : * As above, but it's not dead yet, so abort first.
3388 : */
3389 354 : case TBLOCK_SUBABORT_PENDING:
3390 354 : AbortSubTransaction();
3391 354 : CleanupSubTransaction();
3392 354 : return false;
3393 :
3394 : /*
3395 : * The current subtransaction is the target of a ROLLBACK TO
3396 : * command. Abort and pop it, then start a new subtransaction
3397 : * with the same name.
3398 : */
3399 520 : case TBLOCK_SUBRESTART:
3400 : {
3401 : char *name;
3402 : int savepointLevel;
3403 :
3404 : /* save name and keep Cleanup from freeing it */
3405 520 : name = s->name;
3406 520 : s->name = NULL;
3407 520 : savepointLevel = s->savepointLevel;
3408 :
3409 520 : AbortSubTransaction();
3410 520 : CleanupSubTransaction();
3411 :
3412 520 : DefineSavepoint(NULL);
3413 520 : s = CurrentTransactionState; /* changed by push */
3414 520 : s->name = name;
3415 520 : s->savepointLevel = savepointLevel;
3416 :
3417 : /* This is the same as TBLOCK_SUBBEGIN case */
3418 : Assert(s->blockState == TBLOCK_SUBBEGIN);
3419 520 : StartSubTransaction();
3420 520 : s->blockState = TBLOCK_SUBINPROGRESS;
3421 : }
3422 520 : break;
3423 :
3424 : /*
3425 : * Same as above, but the subtransaction had already failed, so we
3426 : * don't need AbortSubTransaction.
3427 : */
3428 202 : case TBLOCK_SUBABORT_RESTART:
3429 : {
3430 : char *name;
3431 : int savepointLevel;
3432 :
3433 : /* save name and keep Cleanup from freeing it */
3434 202 : name = s->name;
3435 202 : s->name = NULL;
3436 202 : savepointLevel = s->savepointLevel;
3437 :
3438 202 : CleanupSubTransaction();
3439 :
3440 202 : DefineSavepoint(NULL);
3441 202 : s = CurrentTransactionState; /* changed by push */
3442 202 : s->name = name;
3443 202 : s->savepointLevel = savepointLevel;
3444 :
3445 : /* This is the same as TBLOCK_SUBBEGIN case */
3446 : Assert(s->blockState == TBLOCK_SUBBEGIN);
3447 202 : StartSubTransaction();
3448 202 : s->blockState = TBLOCK_SUBINPROGRESS;
3449 : }
3450 202 : break;
3451 : }
3452 :
3453 : /* Done, no more iterations required */
3454 1194606 : return true;
3455 : }
3456 :
3457 : /*
3458 : * AbortCurrentTransaction -- a wrapper function handling the
3459 : * loop over subtransactions to avoid potentially dangerous recursion in
3460 : * AbortCurrentTransactionInternal().
3461 : */
3462 : void
3463 48338 : AbortCurrentTransaction(void)
3464 : {
3465 : /*
3466 : * Repeatedly call AbortCurrentTransactionInternal() until all the work is
3467 : * done.
3468 : */
3469 48338 : while (!AbortCurrentTransactionInternal())
3470 : {
3471 : }
3472 48338 : }
3473 :
3474 : /*
3475 : * AbortCurrentTransactionInternal - a function doing an iteration of work
3476 : * regarding handling the current transaction abort. In the case of
3477 : * subtransactions more than one iterations could be required. Returns
3478 : * true when no more iterations required, false otherwise.
3479 : */
3480 : static bool
3481 48338 : AbortCurrentTransactionInternal(void)
3482 : {
3483 48338 : TransactionState s = CurrentTransactionState;
3484 :
3485 48338 : switch (s->blockState)
3486 : {
3487 98 : case TBLOCK_DEFAULT:
3488 98 : if (s->state == TRANS_DEFAULT)
3489 : {
3490 : /* we are idle, so nothing to do */
3491 : }
3492 : else
3493 : {
3494 : /*
3495 : * We can get here after an error during transaction start
3496 : * (state will be TRANS_START). Need to clean up the
3497 : * incompletely started transaction. First, adjust the
3498 : * low-level state to suppress warning message from
3499 : * AbortTransaction.
3500 : */
3501 0 : if (s->state == TRANS_START)
3502 0 : s->state = TRANS_INPROGRESS;
3503 0 : AbortTransaction();
3504 0 : CleanupTransaction();
3505 : }
3506 98 : break;
3507 :
3508 : /*
3509 : * If we aren't in a transaction block, we just do the basic abort
3510 : * & cleanup transaction. For this purpose, we treat an implicit
3511 : * transaction block as if it were a simple statement.
3512 : */
3513 44060 : case TBLOCK_STARTED:
3514 : case TBLOCK_IMPLICIT_INPROGRESS:
3515 44060 : AbortTransaction();
3516 44060 : CleanupTransaction();
3517 44060 : s->blockState = TBLOCK_DEFAULT;
3518 44060 : break;
3519 :
3520 : /*
3521 : * If we are in TBLOCK_BEGIN it means something screwed up right
3522 : * after reading "BEGIN TRANSACTION". We assume that the user
3523 : * will interpret the error as meaning the BEGIN failed to get him
3524 : * into a transaction block, so we should abort and return to idle
3525 : * state.
3526 : */
3527 0 : case TBLOCK_BEGIN:
3528 0 : AbortTransaction();
3529 0 : CleanupTransaction();
3530 0 : s->blockState = TBLOCK_DEFAULT;
3531 0 : break;
3532 :
3533 : /*
3534 : * We are somewhere in a transaction block and we've gotten a
3535 : * failure, so we abort the transaction and set up the persistent
3536 : * ABORT state. We will stay in ABORT until we get a ROLLBACK.
3537 : */
3538 1398 : case TBLOCK_INPROGRESS:
3539 : case TBLOCK_PARALLEL_INPROGRESS:
3540 1398 : AbortTransaction();
3541 1398 : s->blockState = TBLOCK_ABORT;
3542 : /* CleanupTransaction happens when we exit TBLOCK_ABORT_END */
3543 1398 : break;
3544 :
3545 : /*
3546 : * Here, we failed while trying to COMMIT. Clean up the
3547 : * transaction and return to idle state (we do not want to stay in
3548 : * the transaction).
3549 : */
3550 450 : case TBLOCK_END:
3551 450 : AbortTransaction();
3552 450 : CleanupTransaction();
3553 450 : s->blockState = TBLOCK_DEFAULT;
3554 450 : break;
3555 :
3556 : /*
3557 : * Here, we are already in an aborted transaction state and are
3558 : * waiting for a ROLLBACK, but for some reason we failed again! So
3559 : * we just remain in the abort state.
3560 : */
3561 100 : case TBLOCK_ABORT:
3562 : case TBLOCK_SUBABORT:
3563 100 : break;
3564 :
3565 : /*
3566 : * We are in a failed transaction and we got the ROLLBACK command.
3567 : * We have already aborted, we just need to cleanup and go to idle
3568 : * state.
3569 : */
3570 0 : case TBLOCK_ABORT_END:
3571 0 : CleanupTransaction();
3572 0 : s->blockState = TBLOCK_DEFAULT;
3573 0 : break;
3574 :
3575 : /*
3576 : * We are in a live transaction and we got a ROLLBACK command.
3577 : * Abort, cleanup, go to idle state.
3578 : */
3579 0 : case TBLOCK_ABORT_PENDING:
3580 0 : AbortTransaction();
3581 0 : CleanupTransaction();
3582 0 : s->blockState = TBLOCK_DEFAULT;
3583 0 : break;
3584 :
3585 : /*
3586 : * Here, we failed while trying to PREPARE. Clean up the
3587 : * transaction and return to idle state (we do not want to stay in
3588 : * the transaction).
3589 : */
3590 96 : case TBLOCK_PREPARE:
3591 96 : AbortTransaction();
3592 96 : CleanupTransaction();
3593 96 : s->blockState = TBLOCK_DEFAULT;
3594 96 : break;
3595 :
3596 : /*
3597 : * We got an error inside a subtransaction. Abort just the
3598 : * subtransaction, and go to the persistent SUBABORT state until
3599 : * we get ROLLBACK.
3600 : */
3601 2136 : case TBLOCK_SUBINPROGRESS:
3602 2136 : AbortSubTransaction();
3603 2136 : s->blockState = TBLOCK_SUBABORT;
3604 2136 : break;
3605 :
3606 : /*
3607 : * If we failed while trying to create a subtransaction, clean up
3608 : * the broken subtransaction and abort the parent. The same
3609 : * applies if we get a failure while ending a subtransaction. As
3610 : * we need to abort the parent, return false to request the caller
3611 : * to do the next iteration.
3612 : */
3613 0 : case TBLOCK_SUBBEGIN:
3614 : case TBLOCK_SUBRELEASE:
3615 : case TBLOCK_SUBCOMMIT:
3616 : case TBLOCK_SUBABORT_PENDING:
3617 : case TBLOCK_SUBRESTART:
3618 0 : AbortSubTransaction();
3619 0 : CleanupSubTransaction();
3620 0 : return false;
3621 :
3622 : /*
3623 : * Same as above, except the Abort() was already done.
3624 : */
3625 0 : case TBLOCK_SUBABORT_END:
3626 : case TBLOCK_SUBABORT_RESTART:
3627 0 : CleanupSubTransaction();
3628 0 : return false;
3629 : }
3630 :
3631 : /* Done, no more iterations required */
3632 48338 : return true;
3633 : }
3634 :
3635 : /*
3636 : * PreventInTransactionBlock
3637 : *
3638 : * This routine is to be called by statements that must not run inside
3639 : * a transaction block, typically because they have non-rollback-able
3640 : * side effects or do internal commits.
3641 : *
3642 : * If this routine completes successfully, then the calling statement is
3643 : * guaranteed that if it completes without error, its results will be
3644 : * committed immediately.
3645 : *
3646 : * If we have already started a transaction block, issue an error; also issue
3647 : * an error if we appear to be running inside a user-defined function (which
3648 : * could issue more commands and possibly cause a failure after the statement
3649 : * completes). Subtransactions are verboten too.
3650 : *
3651 : * We must also set XACT_FLAGS_NEEDIMMEDIATECOMMIT in MyXactFlags, to ensure
3652 : * that postgres.c follows through by committing after the statement is done.
3653 : *
3654 : * isTopLevel: passed down from ProcessUtility to determine whether we are
3655 : * inside a function. (We will always fail if this is false, but it's
3656 : * convenient to centralize the check here instead of making callers do it.)
3657 : * stmtType: statement type name, for error messages.
3658 : */
3659 : void
3660 211388 : PreventInTransactionBlock(bool isTopLevel, const char *stmtType)
3661 : {
3662 : /*
3663 : * xact block already started?
3664 : */
3665 211388 : if (IsTransactionBlock())
3666 118 : ereport(ERROR,
3667 : (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3668 : /* translator: %s represents an SQL statement name */
3669 : errmsg("%s cannot run inside a transaction block",
3670 : stmtType)));
3671 :
3672 : /*
3673 : * subtransaction?
3674 : */
3675 211270 : if (IsSubTransaction())
3676 0 : ereport(ERROR,
3677 : (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3678 : /* translator: %s represents an SQL statement name */
3679 : errmsg("%s cannot run inside a subtransaction",
3680 : stmtType)));
3681 :
3682 : /*
3683 : * inside a function call?
3684 : */
3685 211270 : if (!isTopLevel)
3686 6 : ereport(ERROR,
3687 : (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3688 : /* translator: %s represents an SQL statement name */
3689 : errmsg("%s cannot be executed from a function", stmtType)));
3690 :
3691 : /* If we got past IsTransactionBlock test, should be in default state */
3692 211264 : if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
3693 209556 : CurrentTransactionState->blockState != TBLOCK_STARTED)
3694 0 : elog(FATAL, "cannot prevent transaction chain");
3695 :
3696 : /* All okay. Set the flag to make sure the right thing happens later. */
3697 211264 : MyXactFlags |= XACT_FLAGS_NEEDIMMEDIATECOMMIT;
3698 211264 : }
3699 :
3700 : /*
3701 : * WarnNoTransactionBlock
3702 : * RequireTransactionBlock
3703 : *
3704 : * These two functions allow for warnings or errors if a command is executed
3705 : * outside of a transaction block. This is useful for commands that have no
3706 : * effects that persist past transaction end (and so calling them outside a
3707 : * transaction block is presumably an error). DECLARE CURSOR is an example.
3708 : * While top-level transaction control commands (BEGIN/COMMIT/ABORT) and SET
3709 : * that have no effect issue warnings, all other no-effect commands generate
3710 : * errors.
3711 : *
3712 : * If we appear to be running inside a user-defined function, we do not
3713 : * issue anything, since the function could issue more commands that make
3714 : * use of the current statement's results. Likewise subtransactions.
3715 : * Thus these are inverses for PreventInTransactionBlock.
3716 : *
3717 : * isTopLevel: passed down from ProcessUtility to determine whether we are
3718 : * inside a function.
3719 : * stmtType: statement type name, for warning or error messages.
3720 : */
3721 : void
3722 2126 : WarnNoTransactionBlock(bool isTopLevel, const char *stmtType)
3723 : {
3724 2126 : CheckTransactionBlock(isTopLevel, false, stmtType);
3725 2126 : }
3726 :
3727 : void
3728 9880 : RequireTransactionBlock(bool isTopLevel, const char *stmtType)
3729 : {
3730 9880 : CheckTransactionBlock(isTopLevel, true, stmtType);
3731 9844 : }
3732 :
3733 : /*
3734 : * This is the implementation of the above two.
3735 : */
3736 : static void
3737 12006 : CheckTransactionBlock(bool isTopLevel, bool throwError, const char *stmtType)
3738 : {
3739 : /*
3740 : * xact block already started?
3741 : */
3742 12006 : if (IsTransactionBlock())
3743 11832 : return;
3744 :
3745 : /*
3746 : * subtransaction?
3747 : */
3748 174 : if (IsSubTransaction())
3749 0 : return;
3750 :
3751 : /*
3752 : * inside a function call?
3753 : */
3754 174 : if (!isTopLevel)
3755 116 : return;
3756 :
3757 58 : ereport(throwError ? ERROR : WARNING,
3758 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
3759 : /* translator: %s represents an SQL statement name */
3760 : errmsg("%s can only be used in transaction blocks",
3761 : stmtType)));
3762 : }
3763 :
3764 : /*
3765 : * IsInTransactionBlock
3766 : *
3767 : * This routine is for statements that need to behave differently inside
3768 : * a transaction block than when running as single commands. ANALYZE is
3769 : * currently the only example.
3770 : *
3771 : * If this routine returns "false", then the calling statement is allowed
3772 : * to perform internal transaction-commit-and-start cycles; there is not a
3773 : * risk of messing up any transaction already in progress. (Note that this
3774 : * is not the identical guarantee provided by PreventInTransactionBlock,
3775 : * since we will not force a post-statement commit.)
3776 : *
3777 : * isTopLevel: passed down from ProcessUtility to determine whether we are
3778 : * inside a function.
3779 : */
3780 : bool
3781 4978 : IsInTransactionBlock(bool isTopLevel)
3782 : {
3783 : /*
3784 : * Return true on same conditions that would make
3785 : * PreventInTransactionBlock error out
3786 : */
3787 4978 : if (IsTransactionBlock())
3788 138 : return true;
3789 :
3790 4840 : if (IsSubTransaction())
3791 0 : return true;
3792 :
3793 4840 : if (!isTopLevel)
3794 112 : return true;
3795 :
3796 4728 : if (CurrentTransactionState->blockState != TBLOCK_DEFAULT &&
3797 4728 : CurrentTransactionState->blockState != TBLOCK_STARTED)
3798 0 : return true;
3799 :
3800 4728 : return false;
3801 : }
3802 :
3803 :
3804 : /*
3805 : * Register or deregister callback functions for start- and end-of-xact
3806 : * operations.
3807 : *
3808 : * These functions are intended for use by dynamically loaded modules.
3809 : * For built-in modules we generally just hardwire the appropriate calls
3810 : * (mainly because it's easier to control the order that way, where needed).
3811 : *
3812 : * At transaction end, the callback occurs post-commit or post-abort, so the
3813 : * callback functions can only do noncritical cleanup.
3814 : */
3815 : void
3816 3564 : RegisterXactCallback(XactCallback callback, void *arg)
3817 : {
3818 : XactCallbackItem *item;
3819 :
3820 : item = (XactCallbackItem *)
3821 3564 : MemoryContextAlloc(TopMemoryContext, sizeof(XactCallbackItem));
3822 3564 : item->callback = callback;
3823 3564 : item->arg = arg;
3824 3564 : item->next = Xact_callbacks;
3825 3564 : Xact_callbacks = item;
3826 3564 : }
3827 :
3828 : void
3829 0 : UnregisterXactCallback(XactCallback callback, void *arg)
3830 : {
3831 : XactCallbackItem *item;
3832 : XactCallbackItem *prev;
3833 :
3834 0 : prev = NULL;
3835 0 : for (item = Xact_callbacks; item; prev = item, item = item->next)
3836 : {
3837 0 : if (item->callback == callback && item->arg == arg)
3838 : {
3839 0 : if (prev)
3840 0 : prev->next = item->next;
3841 : else
3842 0 : Xact_callbacks = item->next;
3843 0 : pfree(item);
3844 0 : break;
3845 : }
3846 : }
3847 0 : }
3848 :
3849 : static void
3850 2064984 : CallXactCallbacks(XactEvent event)
3851 : {
3852 : XactCallbackItem *item;
3853 : XactCallbackItem *next;
3854 :
3855 2381646 : for (item = Xact_callbacks; item; item = next)
3856 : {
3857 : /* allow callbacks to unregister themselves when called */
3858 316664 : next = item->next;
3859 316664 : item->callback(event, item->arg);
3860 : }
3861 2064982 : }
3862 :
3863 :
3864 : /*
3865 : * Register or deregister callback functions for start- and end-of-subxact
3866 : * operations.
3867 : *
3868 : * Pretty much same as above, but for subtransaction events.
3869 : *
3870 : * At subtransaction end, the callback occurs post-subcommit or post-subabort,
3871 : * so the callback functions can only do noncritical cleanup. At
3872 : * subtransaction start, the callback is called when the subtransaction has
3873 : * finished initializing.
3874 : */
3875 : void
3876 3564 : RegisterSubXactCallback(SubXactCallback callback, void *arg)
3877 : {
3878 : SubXactCallbackItem *item;
3879 :
3880 : item = (SubXactCallbackItem *)
3881 3564 : MemoryContextAlloc(TopMemoryContext, sizeof(SubXactCallbackItem));
3882 3564 : item->callback = callback;
3883 3564 : item->arg = arg;
3884 3564 : item->next = SubXact_callbacks;
3885 3564 : SubXact_callbacks = item;
3886 3564 : }
3887 :
3888 : void
3889 0 : UnregisterSubXactCallback(SubXactCallback callback, void *arg)
3890 : {
3891 : SubXactCallbackItem *item;
3892 : SubXactCallbackItem *prev;
3893 :
3894 0 : prev = NULL;
3895 0 : for (item = SubXact_callbacks; item; prev = item, item = item->next)
3896 : {
3897 0 : if (item->callback == callback && item->arg == arg)
3898 : {
3899 0 : if (prev)
3900 0 : prev->next = item->next;
3901 : else
3902 0 : SubXact_callbacks = item->next;
3903 0 : pfree(item);
3904 0 : break;
3905 : }
3906 : }
3907 0 : }
3908 :
3909 : static void
3910 50790 : CallSubXactCallbacks(SubXactEvent event,
3911 : SubTransactionId mySubid,
3912 : SubTransactionId parentSubid)
3913 : {
3914 : SubXactCallbackItem *item;
3915 : SubXactCallbackItem *next;
3916 :
3917 90504 : for (item = SubXact_callbacks; item; item = next)
3918 : {
3919 : /* allow callbacks to unregister themselves when called */
3920 39714 : next = item->next;
3921 39714 : item->callback(event, mySubid, parentSubid, item->arg);
3922 : }
3923 50790 : }
3924 :
3925 :
3926 : /* ----------------------------------------------------------------
3927 : * transaction block support
3928 : * ----------------------------------------------------------------
3929 : */
3930 :
3931 : /*
3932 : * BeginTransactionBlock
3933 : * This executes a BEGIN command.
3934 : */
3935 : void
3936 17650 : BeginTransactionBlock(void)
3937 : {
3938 17650 : TransactionState s = CurrentTransactionState;
3939 :
3940 17650 : switch (s->blockState)
3941 : {
3942 : /*
3943 : * We are not inside a transaction block, so allow one to begin.
3944 : */
3945 16686 : case TBLOCK_STARTED:
3946 16686 : s->blockState = TBLOCK_BEGIN;
3947 16686 : break;
3948 :
3949 : /*
3950 : * BEGIN converts an implicit transaction block to a regular one.
3951 : * (Note that we allow this even if we've already done some
3952 : * commands, which is a bit odd but matches historical practice.)
3953 : */
3954 964 : case TBLOCK_IMPLICIT_INPROGRESS:
3955 964 : s->blockState = TBLOCK_BEGIN;
3956 964 : break;
3957 :
3958 : /*
3959 : * Already a transaction block in progress.
3960 : */
3961 0 : case TBLOCK_INPROGRESS:
3962 : case TBLOCK_PARALLEL_INPROGRESS:
3963 : case TBLOCK_SUBINPROGRESS:
3964 : case TBLOCK_ABORT:
3965 : case TBLOCK_SUBABORT:
3966 0 : ereport(WARNING,
3967 : (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
3968 : errmsg("there is already a transaction in progress")));
3969 0 : break;
3970 :
3971 : /* These cases are invalid. */
3972 0 : case TBLOCK_DEFAULT:
3973 : case TBLOCK_BEGIN:
3974 : case TBLOCK_SUBBEGIN:
3975 : case TBLOCK_END:
3976 : case TBLOCK_SUBRELEASE:
3977 : case TBLOCK_SUBCOMMIT:
3978 : case TBLOCK_ABORT_END:
3979 : case TBLOCK_SUBABORT_END:
3980 : case TBLOCK_ABORT_PENDING:
3981 : case TBLOCK_SUBABORT_PENDING:
3982 : case TBLOCK_SUBRESTART:
3983 : case TBLOCK_SUBABORT_RESTART:
3984 : case TBLOCK_PREPARE:
3985 0 : elog(FATAL, "BeginTransactionBlock: unexpected state %s",
3986 : BlockStateAsString(s->blockState));
3987 : break;
3988 : }
3989 17650 : }
3990 :
3991 : /*
3992 : * PrepareTransactionBlock
3993 : * This executes a PREPARE command.
3994 : *
3995 : * Since PREPARE may actually do a ROLLBACK, the result indicates what
3996 : * happened: true for PREPARE, false for ROLLBACK.
3997 : *
3998 : * Note that we don't actually do anything here except change blockState.
3999 : * The real work will be done in the upcoming PrepareTransaction().
4000 : * We do it this way because it's not convenient to change memory context,
4001 : * resource owner, etc while executing inside a Portal.
4002 : */
4003 : bool
4004 672 : PrepareTransactionBlock(const char *gid)
4005 : {
4006 : TransactionState s;
4007 : bool result;
4008 :
4009 : /* Set up to commit the current transaction */
4010 672 : result = EndTransactionBlock(false);
4011 :
4012 : /* If successful, change outer tblock state to PREPARE */
4013 672 : if (result)
4014 : {
4015 668 : s = CurrentTransactionState;
4016 :
4017 890 : while (s->parent != NULL)
4018 222 : s = s->parent;
4019 :
4020 668 : if (s->blockState == TBLOCK_END)
4021 : {
4022 : /* Save GID where PrepareTransaction can find it again */
4023 668 : prepareGID = MemoryContextStrdup(TopTransactionContext, gid);
4024 :
4025 668 : s->blockState = TBLOCK_PREPARE;
4026 : }
4027 : else
4028 : {
4029 : /*
4030 : * ignore case where we are not in a transaction;
4031 : * EndTransactionBlock already issued a warning.
4032 : */
4033 : Assert(s->blockState == TBLOCK_STARTED ||
4034 : s->blockState == TBLOCK_IMPLICIT_INPROGRESS);
4035 : /* Don't send back a PREPARE result tag... */
4036 0 : result = false;
4037 : }
4038 : }
4039 :
4040 672 : return result;
4041 : }
4042 :
4043 : /*
4044 : * EndTransactionBlock
4045 : * This executes a COMMIT command.
4046 : *
4047 : * Since COMMIT may actually do a ROLLBACK, the result indicates what
4048 : * happened: true for COMMIT, false for ROLLBACK.
4049 : *
4050 : * Note that we don't actually do anything here except change blockState.
4051 : * The real work will be done in the upcoming CommitTransactionCommand().
4052 : * We do it this way because it's not convenient to change memory context,
4053 : * resource owner, etc while executing inside a Portal.
4054 : */
4055 : bool
4056 14322 : EndTransactionBlock(bool chain)
4057 : {
4058 14322 : TransactionState s = CurrentTransactionState;
4059 14322 : bool result = false;
4060 :
4061 14322 : switch (s->blockState)
4062 : {
4063 : /*
4064 : * We are in a transaction block, so tell CommitTransactionCommand
4065 : * to COMMIT.
4066 : */
4067 12534 : case TBLOCK_INPROGRESS:
4068 12534 : s->blockState = TBLOCK_END;
4069 12534 : result = true;
4070 12534 : break;
4071 :
4072 : /*
4073 : * We are in an implicit transaction block. If AND CHAIN was
4074 : * specified, error. Otherwise commit, but issue a warning
4075 : * because there was no explicit BEGIN before this.
4076 : */
4077 48 : case TBLOCK_IMPLICIT_INPROGRESS:
4078 48 : if (chain)
4079 24 : ereport(ERROR,
4080 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4081 : /* translator: %s represents an SQL statement name */
4082 : errmsg("%s can only be used in transaction blocks",
4083 : "COMMIT AND CHAIN")));
4084 : else
4085 24 : ereport(WARNING,
4086 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4087 : errmsg("there is no transaction in progress")));
4088 24 : s->blockState = TBLOCK_END;
4089 24 : result = true;
4090 24 : break;
4091 :
4092 : /*
4093 : * We are in a failed transaction block. Tell
4094 : * CommitTransactionCommand it's time to exit the block.
4095 : */
4096 714 : case TBLOCK_ABORT:
4097 714 : s->blockState = TBLOCK_ABORT_END;
4098 714 : break;
4099 :
4100 : /*
4101 : * We are in a live subtransaction block. Set up to subcommit all
4102 : * open subtransactions and then commit the main transaction.
4103 : */
4104 942 : case TBLOCK_SUBINPROGRESS:
4105 2018 : while (s->parent != NULL)
4106 : {
4107 1076 : if (s->blockState == TBLOCK_SUBINPROGRESS)
4108 1076 : s->blockState = TBLOCK_SUBCOMMIT;
4109 : else
4110 0 : elog(FATAL, "EndTransactionBlock: unexpected state %s",
4111 : BlockStateAsString(s->blockState));
4112 1076 : s = s->parent;
4113 : }
4114 942 : if (s->blockState == TBLOCK_INPROGRESS)
4115 942 : s->blockState = TBLOCK_END;
4116 : else
4117 0 : elog(FATAL, "EndTransactionBlock: unexpected state %s",
4118 : BlockStateAsString(s->blockState));
4119 942 : result = true;
4120 942 : break;
4121 :
4122 : /*
4123 : * Here we are inside an aborted subtransaction. Treat the COMMIT
4124 : * as ROLLBACK: set up to abort everything and exit the main
4125 : * transaction.
4126 : */
4127 60 : case TBLOCK_SUBABORT:
4128 120 : while (s->parent != NULL)
4129 : {
4130 60 : if (s->blockState == TBLOCK_SUBINPROGRESS)
4131 0 : s->blockState = TBLOCK_SUBABORT_PENDING;
4132 60 : else if (s->blockState == TBLOCK_SUBABORT)
4133 60 : s->blockState = TBLOCK_SUBABORT_END;
4134 : else
4135 0 : elog(FATAL, "EndTransactionBlock: unexpected state %s",
4136 : BlockStateAsString(s->blockState));
4137 60 : s = s->parent;
4138 : }
4139 60 : if (s->blockState == TBLOCK_INPROGRESS)
4140 60 : s->blockState = TBLOCK_ABORT_PENDING;
4141 0 : else if (s->blockState == TBLOCK_ABORT)
4142 0 : s->blockState = TBLOCK_ABORT_END;
4143 : else
4144 0 : elog(FATAL, "EndTransactionBlock: unexpected state %s",
4145 : BlockStateAsString(s->blockState));
4146 60 : break;
4147 :
4148 : /*
4149 : * The user issued COMMIT when not inside a transaction. For
4150 : * COMMIT without CHAIN, issue a WARNING, staying in
4151 : * TBLOCK_STARTED state. The upcoming call to
4152 : * CommitTransactionCommand() will then close the transaction and
4153 : * put us back into the default state. For COMMIT AND CHAIN,
4154 : * error.
4155 : */
4156 24 : case TBLOCK_STARTED:
4157 24 : if (chain)
4158 6 : ereport(ERROR,
4159 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4160 : /* translator: %s represents an SQL statement name */
4161 : errmsg("%s can only be used in transaction blocks",
4162 : "COMMIT AND CHAIN")));
4163 : else
4164 18 : ereport(WARNING,
4165 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4166 : errmsg("there is no transaction in progress")));
4167 18 : result = true;
4168 18 : break;
4169 :
4170 : /*
4171 : * The user issued a COMMIT that somehow ran inside a parallel
4172 : * worker. We can't cope with that.
4173 : */
4174 0 : case TBLOCK_PARALLEL_INPROGRESS:
4175 0 : ereport(FATAL,
4176 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4177 : errmsg("cannot commit during a parallel operation")));
4178 : break;
4179 :
4180 : /* These cases are invalid. */
4181 0 : case TBLOCK_DEFAULT:
4182 : case TBLOCK_BEGIN:
4183 : case TBLOCK_SUBBEGIN:
4184 : case TBLOCK_END:
4185 : case TBLOCK_SUBRELEASE:
4186 : case TBLOCK_SUBCOMMIT:
4187 : case TBLOCK_ABORT_END:
4188 : case TBLOCK_SUBABORT_END:
4189 : case TBLOCK_ABORT_PENDING:
4190 : case TBLOCK_SUBABORT_PENDING:
4191 : case TBLOCK_SUBRESTART:
4192 : case TBLOCK_SUBABORT_RESTART:
4193 : case TBLOCK_PREPARE:
4194 0 : elog(FATAL, "EndTransactionBlock: unexpected state %s",
4195 : BlockStateAsString(s->blockState));
4196 : break;
4197 : }
4198 :
4199 : Assert(s->blockState == TBLOCK_STARTED ||
4200 : s->blockState == TBLOCK_END ||
4201 : s->blockState == TBLOCK_ABORT_END ||
4202 : s->blockState == TBLOCK_ABORT_PENDING);
4203 :
4204 14292 : s->chain = chain;
4205 :
4206 14292 : return result;
4207 : }
4208 :
4209 : /*
4210 : * UserAbortTransactionBlock
4211 : * This executes a ROLLBACK command.
4212 : *
4213 : * As above, we don't actually do anything here except change blockState.
4214 : */
4215 : void
4216 2852 : UserAbortTransactionBlock(bool chain)
4217 : {
4218 2852 : TransactionState s = CurrentTransactionState;
4219 :
4220 2852 : switch (s->blockState)
4221 : {
4222 : /*
4223 : * We are inside a transaction block and we got a ROLLBACK command
4224 : * from the user, so tell CommitTransactionCommand to abort and
4225 : * exit the transaction block.
4226 : */
4227 2002 : case TBLOCK_INPROGRESS:
4228 2002 : s->blockState = TBLOCK_ABORT_PENDING;
4229 2002 : break;
4230 :
4231 : /*
4232 : * We are inside a failed transaction block and we got a ROLLBACK
4233 : * command from the user. Abort processing is already done, so
4234 : * CommitTransactionCommand just has to cleanup and go back to
4235 : * idle state.
4236 : */
4237 662 : case TBLOCK_ABORT:
4238 662 : s->blockState = TBLOCK_ABORT_END;
4239 662 : break;
4240 :
4241 : /*
4242 : * We are inside a subtransaction. Mark everything up to top
4243 : * level as exitable.
4244 : */
4245 110 : case TBLOCK_SUBINPROGRESS:
4246 : case TBLOCK_SUBABORT:
4247 432 : while (s->parent != NULL)
4248 : {
4249 322 : if (s->blockState == TBLOCK_SUBINPROGRESS)
4250 302 : s->blockState = TBLOCK_SUBABORT_PENDING;
4251 20 : else if (s->blockState == TBLOCK_SUBABORT)
4252 20 : s->blockState = TBLOCK_SUBABORT_END;
4253 : else
4254 0 : elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4255 : BlockStateAsString(s->blockState));
4256 322 : s = s->parent;
4257 : }
4258 110 : if (s->blockState == TBLOCK_INPROGRESS)
4259 110 : s->blockState = TBLOCK_ABORT_PENDING;
4260 0 : else if (s->blockState == TBLOCK_ABORT)
4261 0 : s->blockState = TBLOCK_ABORT_END;
4262 : else
4263 0 : elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4264 : BlockStateAsString(s->blockState));
4265 110 : break;
4266 :
4267 : /*
4268 : * The user issued ABORT when not inside a transaction. For
4269 : * ROLLBACK without CHAIN, issue a WARNING and go to abort state.
4270 : * The upcoming call to CommitTransactionCommand() will then put
4271 : * us back into the default state. For ROLLBACK AND CHAIN, error.
4272 : *
4273 : * We do the same thing with ABORT inside an implicit transaction,
4274 : * although in this case we might be rolling back actual database
4275 : * state changes. (It's debatable whether we should issue a
4276 : * WARNING in this case, but we have done so historically.)
4277 : */
4278 78 : case TBLOCK_STARTED:
4279 : case TBLOCK_IMPLICIT_INPROGRESS:
4280 78 : if (chain)
4281 30 : ereport(ERROR,
4282 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4283 : /* translator: %s represents an SQL statement name */
4284 : errmsg("%s can only be used in transaction blocks",
4285 : "ROLLBACK AND CHAIN")));
4286 : else
4287 48 : ereport(WARNING,
4288 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4289 : errmsg("there is no transaction in progress")));
4290 48 : s->blockState = TBLOCK_ABORT_PENDING;
4291 48 : break;
4292 :
4293 : /*
4294 : * The user issued an ABORT that somehow ran inside a parallel
4295 : * worker. We can't cope with that.
4296 : */
4297 0 : case TBLOCK_PARALLEL_INPROGRESS:
4298 0 : ereport(FATAL,
4299 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4300 : errmsg("cannot abort during a parallel operation")));
4301 : break;
4302 :
4303 : /* These cases are invalid. */
4304 0 : case TBLOCK_DEFAULT:
4305 : case TBLOCK_BEGIN:
4306 : case TBLOCK_SUBBEGIN:
4307 : case TBLOCK_END:
4308 : case TBLOCK_SUBRELEASE:
4309 : case TBLOCK_SUBCOMMIT:
4310 : case TBLOCK_ABORT_END:
4311 : case TBLOCK_SUBABORT_END:
4312 : case TBLOCK_ABORT_PENDING:
4313 : case TBLOCK_SUBABORT_PENDING:
4314 : case TBLOCK_SUBRESTART:
4315 : case TBLOCK_SUBABORT_RESTART:
4316 : case TBLOCK_PREPARE:
4317 0 : elog(FATAL, "UserAbortTransactionBlock: unexpected state %s",
4318 : BlockStateAsString(s->blockState));
4319 : break;
4320 : }
4321 :
4322 : Assert(s->blockState == TBLOCK_ABORT_END ||
4323 : s->blockState == TBLOCK_ABORT_PENDING);
4324 :
4325 2822 : s->chain = chain;
4326 2822 : }
4327 :
4328 : /*
4329 : * BeginImplicitTransactionBlock
4330 : * Start an implicit transaction block if we're not already in one.
4331 : *
4332 : * Unlike BeginTransactionBlock, this is called directly from the main loop
4333 : * in postgres.c, not within a Portal. So we can just change blockState
4334 : * without a lot of ceremony. We do not expect caller to do
4335 : * CommitTransactionCommand/StartTransactionCommand.
4336 : */
4337 : void
4338 89784 : BeginImplicitTransactionBlock(void)
4339 : {
4340 89784 : TransactionState s = CurrentTransactionState;
4341 :
4342 : /*
4343 : * If we are in STARTED state (that is, no transaction block is open),
4344 : * switch to IMPLICIT_INPROGRESS state, creating an implicit transaction
4345 : * block.
4346 : *
4347 : * For caller convenience, we consider all other transaction states as
4348 : * legal here; otherwise the caller would need its own state check, which
4349 : * seems rather pointless.
4350 : */
4351 89784 : if (s->blockState == TBLOCK_STARTED)
4352 10800 : s->blockState = TBLOCK_IMPLICIT_INPROGRESS;
4353 89784 : }
4354 :
4355 : /*
4356 : * EndImplicitTransactionBlock
4357 : * End an implicit transaction block, if we're in one.
4358 : *
4359 : * Like EndTransactionBlock, we just make any needed blockState change here.
4360 : * The real work will be done in the upcoming CommitTransactionCommand().
4361 : */
4362 : void
4363 36144 : EndImplicitTransactionBlock(void)
4364 : {
4365 36144 : TransactionState s = CurrentTransactionState;
4366 :
4367 : /*
4368 : * If we are in IMPLICIT_INPROGRESS state, switch back to STARTED state,
4369 : * allowing CommitTransactionCommand to commit whatever happened during
4370 : * the implicit transaction block as though it were a single statement.
4371 : *
4372 : * For caller convenience, we consider all other transaction states as
4373 : * legal here; otherwise the caller would need its own state check, which
4374 : * seems rather pointless.
4375 : */
4376 36144 : if (s->blockState == TBLOCK_IMPLICIT_INPROGRESS)
4377 9664 : s->blockState = TBLOCK_STARTED;
4378 36144 : }
4379 :
4380 : /*
4381 : * DefineSavepoint
4382 : * This executes a SAVEPOINT command.
4383 : */
4384 : void
4385 2692 : DefineSavepoint(const char *name)
4386 : {
4387 2692 : TransactionState s = CurrentTransactionState;
4388 :
4389 : /*
4390 : * Workers synchronize transaction state at the beginning of each parallel
4391 : * operation, so we can't account for new subtransactions after that
4392 : * point. (Note that this check will certainly error out if s->blockState
4393 : * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4394 : * below.)
4395 : */
4396 2692 : if (IsInParallelMode() || IsParallelWorker())
4397 0 : ereport(ERROR,
4398 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4399 : errmsg("cannot define savepoints during a parallel operation")));
4400 :
4401 2692 : switch (s->blockState)
4402 : {
4403 2680 : case TBLOCK_INPROGRESS:
4404 : case TBLOCK_SUBINPROGRESS:
4405 : /* Normal subtransaction start */
4406 2680 : PushTransaction();
4407 2680 : s = CurrentTransactionState; /* changed by push */
4408 :
4409 : /*
4410 : * Savepoint names, like the TransactionState block itself, live
4411 : * in TopTransactionContext.
4412 : */
4413 2680 : if (name)
4414 1958 : s->name = MemoryContextStrdup(TopTransactionContext, name);
4415 2680 : break;
4416 :
4417 : /*
4418 : * We disallow savepoint commands in implicit transaction blocks.
4419 : * There would be no great difficulty in allowing them so far as
4420 : * this module is concerned, but a savepoint seems inconsistent
4421 : * with exec_simple_query's behavior of abandoning the whole query
4422 : * string upon error. Also, the point of an implicit transaction
4423 : * block (as opposed to a regular one) is to automatically close
4424 : * after an error, so it's hard to see how a savepoint would fit
4425 : * into that.
4426 : *
4427 : * The error messages for this are phrased as if there were no
4428 : * active transaction block at all, which is historical but
4429 : * perhaps could be improved.
4430 : */
4431 12 : case TBLOCK_IMPLICIT_INPROGRESS:
4432 12 : ereport(ERROR,
4433 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4434 : /* translator: %s represents an SQL statement name */
4435 : errmsg("%s can only be used in transaction blocks",
4436 : "SAVEPOINT")));
4437 : break;
4438 :
4439 : /* These cases are invalid. */
4440 0 : case TBLOCK_DEFAULT:
4441 : case TBLOCK_STARTED:
4442 : case TBLOCK_BEGIN:
4443 : case TBLOCK_PARALLEL_INPROGRESS:
4444 : case TBLOCK_SUBBEGIN:
4445 : case TBLOCK_END:
4446 : case TBLOCK_SUBRELEASE:
4447 : case TBLOCK_SUBCOMMIT:
4448 : case TBLOCK_ABORT:
4449 : case TBLOCK_SUBABORT:
4450 : case TBLOCK_ABORT_END:
4451 : case TBLOCK_SUBABORT_END:
4452 : case TBLOCK_ABORT_PENDING:
4453 : case TBLOCK_SUBABORT_PENDING:
4454 : case TBLOCK_SUBRESTART:
4455 : case TBLOCK_SUBABORT_RESTART:
4456 : case TBLOCK_PREPARE:
4457 0 : elog(FATAL, "DefineSavepoint: unexpected state %s",
4458 : BlockStateAsString(s->blockState));
4459 : break;
4460 : }
4461 2680 : }
4462 :
4463 : /*
4464 : * ReleaseSavepoint
4465 : * This executes a RELEASE command.
4466 : *
4467 : * As above, we don't actually do anything here except change blockState.
4468 : */
4469 : void
4470 282 : ReleaseSavepoint(const char *name)
4471 : {
4472 282 : TransactionState s = CurrentTransactionState;
4473 : TransactionState target,
4474 : xact;
4475 :
4476 : /*
4477 : * Workers synchronize transaction state at the beginning of each parallel
4478 : * operation, so we can't account for transaction state change after that
4479 : * point. (Note that this check will certainly error out if s->blockState
4480 : * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4481 : * below.)
4482 : */
4483 282 : if (IsInParallelMode() || IsParallelWorker())
4484 0 : ereport(ERROR,
4485 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4486 : errmsg("cannot release savepoints during a parallel operation")));
4487 :
4488 282 : switch (s->blockState)
4489 : {
4490 : /*
4491 : * We can't release a savepoint if there is no savepoint defined.
4492 : */
4493 0 : case TBLOCK_INPROGRESS:
4494 0 : ereport(ERROR,
4495 : (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4496 : errmsg("savepoint \"%s\" does not exist", name)));
4497 : break;
4498 :
4499 6 : case TBLOCK_IMPLICIT_INPROGRESS:
4500 : /* See comment about implicit transactions in DefineSavepoint */
4501 6 : ereport(ERROR,
4502 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4503 : /* translator: %s represents an SQL statement name */
4504 : errmsg("%s can only be used in transaction blocks",
4505 : "RELEASE SAVEPOINT")));
4506 : break;
4507 :
4508 : /*
4509 : * We are in a non-aborted subtransaction. This is the only valid
4510 : * case.
4511 : */
4512 276 : case TBLOCK_SUBINPROGRESS:
4513 276 : break;
4514 :
4515 : /* These cases are invalid. */
4516 0 : case TBLOCK_DEFAULT:
4517 : case TBLOCK_STARTED:
4518 : case TBLOCK_BEGIN:
4519 : case TBLOCK_PARALLEL_INPROGRESS:
4520 : case TBLOCK_SUBBEGIN:
4521 : case TBLOCK_END:
4522 : case TBLOCK_SUBRELEASE:
4523 : case TBLOCK_SUBCOMMIT:
4524 : case TBLOCK_ABORT:
4525 : case TBLOCK_SUBABORT:
4526 : case TBLOCK_ABORT_END:
4527 : case TBLOCK_SUBABORT_END:
4528 : case TBLOCK_ABORT_PENDING:
4529 : case TBLOCK_SUBABORT_PENDING:
4530 : case TBLOCK_SUBRESTART:
4531 : case TBLOCK_SUBABORT_RESTART:
4532 : case TBLOCK_PREPARE:
4533 0 : elog(FATAL, "ReleaseSavepoint: unexpected state %s",
4534 : BlockStateAsString(s->blockState));
4535 : break;
4536 : }
4537 :
4538 448 : for (target = s; PointerIsValid(target); target = target->parent)
4539 : {
4540 448 : if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
4541 276 : break;
4542 : }
4543 :
4544 276 : if (!PointerIsValid(target))
4545 0 : ereport(ERROR,
4546 : (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4547 : errmsg("savepoint \"%s\" does not exist", name)));
4548 :
4549 : /* disallow crossing savepoint level boundaries */
4550 276 : if (target->savepointLevel != s->savepointLevel)
4551 0 : ereport(ERROR,
4552 : (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4553 : errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
4554 :
4555 : /*
4556 : * Mark "commit pending" all subtransactions up to the target
4557 : * subtransaction. The actual commits will happen when control gets to
4558 : * CommitTransactionCommand.
4559 : */
4560 276 : xact = CurrentTransactionState;
4561 : for (;;)
4562 : {
4563 172 : Assert(xact->blockState == TBLOCK_SUBINPROGRESS);
4564 448 : xact->blockState = TBLOCK_SUBRELEASE;
4565 448 : if (xact == target)
4566 276 : break;
4567 172 : xact = xact->parent;
4568 : Assert(PointerIsValid(xact));
4569 : }
4570 276 : }
4571 :
4572 : /*
4573 : * RollbackToSavepoint
4574 : * This executes a ROLLBACK TO <savepoint> command.
4575 : *
4576 : * As above, we don't actually do anything here except change blockState.
4577 : */
4578 : void
4579 734 : RollbackToSavepoint(const char *name)
4580 : {
4581 734 : TransactionState s = CurrentTransactionState;
4582 : TransactionState target,
4583 : xact;
4584 :
4585 : /*
4586 : * Workers synchronize transaction state at the beginning of each parallel
4587 : * operation, so we can't account for transaction state change after that
4588 : * point. (Note that this check will certainly error out if s->blockState
4589 : * is TBLOCK_PARALLEL_INPROGRESS, so we can treat that as an invalid case
4590 : * below.)
4591 : */
4592 734 : if (IsInParallelMode() || IsParallelWorker())
4593 0 : ereport(ERROR,
4594 : (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
4595 : errmsg("cannot rollback to savepoints during a parallel operation")));
4596 :
4597 734 : switch (s->blockState)
4598 : {
4599 : /*
4600 : * We can't rollback to a savepoint if there is no savepoint
4601 : * defined.
4602 : */
4603 6 : case TBLOCK_INPROGRESS:
4604 : case TBLOCK_ABORT:
4605 6 : ereport(ERROR,
4606 : (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4607 : errmsg("savepoint \"%s\" does not exist", name)));
4608 : break;
4609 :
4610 6 : case TBLOCK_IMPLICIT_INPROGRESS:
4611 : /* See comment about implicit transactions in DefineSavepoint */
4612 6 : ereport(ERROR,
4613 : (errcode(ERRCODE_NO_ACTIVE_SQL_TRANSACTION),
4614 : /* translator: %s represents an SQL statement name */
4615 : errmsg("%s can only be used in transaction blocks",
4616 : "ROLLBACK TO SAVEPOINT")));
4617 : break;
4618 :
4619 : /*
4620 : * There is at least one savepoint, so proceed.
4621 : */
4622 722 : case TBLOCK_SUBINPROGRESS:
4623 : case TBLOCK_SUBABORT:
4624 722 : break;
4625 :
4626 : /* These cases are invalid. */
4627 0 : case TBLOCK_DEFAULT:
4628 : case TBLOCK_STARTED:
4629 : case TBLOCK_BEGIN:
4630 : case TBLOCK_PARALLEL_INPROGRESS:
4631 : case TBLOCK_SUBBEGIN:
4632 : case TBLOCK_END:
4633 : case TBLOCK_SUBRELEASE:
4634 : case TBLOCK_SUBCOMMIT:
4635 : case TBLOCK_ABORT_END:
4636 : case TBLOCK_SUBABORT_END:
4637 : case TBLOCK_ABORT_PENDING:
4638 : case TBLOCK_SUBABORT_PENDING:
4639 : case TBLOCK_SUBRESTART:
4640 : case TBLOCK_SUBABORT_RESTART:
4641 : case TBLOCK_PREPARE:
4642 0 : elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4643 : BlockStateAsString(s->blockState));
4644 : break;
4645 : }
4646 :
4647 774 : for (target = s; PointerIsValid(target); target = target->parent)
4648 : {
4649 774 : if (PointerIsValid(target->name) && strcmp(target->name, name) == 0)
4650 722 : break;
4651 : }
4652 :
4653 722 : if (!PointerIsValid(target))
4654 0 : ereport(ERROR,
4655 : (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4656 : errmsg("savepoint \"%s\" does not exist", name)));
4657 :
4658 : /* disallow crossing savepoint level boundaries */
4659 722 : if (target->savepointLevel != s->savepointLevel)
4660 0 : ereport(ERROR,
4661 : (errcode(ERRCODE_S_E_INVALID_SPECIFICATION),
4662 : errmsg("savepoint \"%s\" does not exist within current savepoint level", name)));
4663 :
4664 : /*
4665 : * Mark "abort pending" all subtransactions up to the target
4666 : * subtransaction. The actual aborts will happen when control gets to
4667 : * CommitTransactionCommand.
4668 : */
4669 722 : xact = CurrentTransactionState;
4670 : for (;;)
4671 : {
4672 774 : if (xact == target)
4673 722 : break;
4674 52 : if (xact->blockState == TBLOCK_SUBINPROGRESS)
4675 52 : xact->blockState = TBLOCK_SUBABORT_PENDING;
4676 0 : else if (xact->blockState == TBLOCK_SUBABORT)
4677 0 : xact->blockState = TBLOCK_SUBABORT_END;
4678 : else
4679 0 : elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4680 : BlockStateAsString(xact->blockState));
4681 52 : xact = xact->parent;
4682 : Assert(PointerIsValid(xact));
4683 : }
4684 :
4685 : /* And mark the target as "restart pending" */
4686 722 : if (xact->blockState == TBLOCK_SUBINPROGRESS)
4687 520 : xact->blockState = TBLOCK_SUBRESTART;
4688 202 : else if (xact->blockState == TBLOCK_SUBABORT)
4689 202 : xact->blockState = TBLOCK_SUBABORT_RESTART;
4690 : else
4691 0 : elog(FATAL, "RollbackToSavepoint: unexpected state %s",
4692 : BlockStateAsString(xact->blockState));
4693 722 : }
4694 :
4695 : /*
4696 : * BeginInternalSubTransaction
4697 : * This is the same as DefineSavepoint except it allows TBLOCK_STARTED,
4698 : * TBLOCK_IMPLICIT_INPROGRESS, TBLOCK_PARALLEL_INPROGRESS, TBLOCK_END,
4699 : * and TBLOCK_PREPARE states, and therefore it can safely be used in
4700 : * functions that might be called when not inside a BEGIN block or when
4701 : * running deferred triggers at COMMIT/PREPARE time. Also, it
4702 : * automatically does CommitTransactionCommand/StartTransactionCommand
4703 : * instead of expecting the caller to do it.
4704 : */
4705 : void
4706 17372 : BeginInternalSubTransaction(const char *name)
4707 : {
4708 17372 : TransactionState s = CurrentTransactionState;
4709 17372 : bool save_ExitOnAnyError = ExitOnAnyError;
4710 :
4711 : /*
4712 : * Errors within this function are improbable, but if one does happen we
4713 : * force a FATAL exit. Callers generally aren't prepared to handle losing
4714 : * control, and moreover our transaction state is probably corrupted if we
4715 : * fail partway through; so an ordinary ERROR longjmp isn't okay.
4716 : */
4717 17372 : ExitOnAnyError = true;
4718 :
4719 : /*
4720 : * We do not check for parallel mode here. It's permissible to start and
4721 : * end "internal" subtransactions while in parallel mode, so long as no
4722 : * new XIDs or command IDs are assigned. Enforcement of that occurs in
4723 : * AssignTransactionId() and CommandCounterIncrement().
4724 : */
4725 :
4726 17372 : switch (s->blockState)
4727 : {
4728 17372 : case TBLOCK_STARTED:
4729 : case TBLOCK_INPROGRESS:
4730 : case TBLOCK_IMPLICIT_INPROGRESS:
4731 : case TBLOCK_PARALLEL_INPROGRESS:
4732 : case TBLOCK_END:
4733 : case TBLOCK_PREPARE:
4734 : case TBLOCK_SUBINPROGRESS:
4735 : /* Normal subtransaction start */
4736 17372 : PushTransaction();
4737 17372 : s = CurrentTransactionState; /* changed by push */
4738 :
4739 : /*
4740 : * Savepoint names, like the TransactionState block itself, live
4741 : * in TopTransactionContext.
4742 : */
4743 17372 : if (name)
4744 1854 : s->name = MemoryContextStrdup(TopTransactionContext, name);
4745 17372 : break;
4746 :
4747 : /* These cases are invalid. */
4748 0 : case TBLOCK_DEFAULT:
4749 : case TBLOCK_BEGIN:
4750 : case TBLOCK_SUBBEGIN:
4751 : case TBLOCK_SUBRELEASE:
4752 : case TBLOCK_SUBCOMMIT:
4753 : case TBLOCK_ABORT:
4754 : case TBLOCK_SUBABORT:
4755 : case TBLOCK_ABORT_END:
4756 : case TBLOCK_SUBABORT_END:
4757 : case TBLOCK_ABORT_PENDING:
4758 : case TBLOCK_SUBABORT_PENDING:
4759 : case TBLOCK_SUBRESTART:
4760 : case TBLOCK_SUBABORT_RESTART:
4761 0 : elog(FATAL, "BeginInternalSubTransaction: unexpected state %s",
4762 : BlockStateAsString(s->blockState));
4763 : break;
4764 : }
4765 :
4766 17372 : CommitTransactionCommand();
4767 17372 : StartTransactionCommand();
4768 :
4769 17372 : ExitOnAnyError = save_ExitOnAnyError;
4770 17372 : }
4771 :
4772 : /*
4773 : * ReleaseCurrentSubTransaction
4774 : *
4775 : * RELEASE (ie, commit) the innermost subtransaction, regardless of its
4776 : * savepoint name (if any).
4777 : * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4778 : */
4779 : void
4780 9162 : ReleaseCurrentSubTransaction(void)
4781 : {
4782 9162 : TransactionState s = CurrentTransactionState;
4783 :
4784 : /*
4785 : * We do not check for parallel mode here. It's permissible to start and
4786 : * end "internal" subtransactions while in parallel mode, so long as no
4787 : * new XIDs or command IDs are assigned.
4788 : */
4789 :
4790 9162 : if (s->blockState != TBLOCK_SUBINPROGRESS)
4791 0 : elog(ERROR, "ReleaseCurrentSubTransaction: unexpected state %s",
4792 : BlockStateAsString(s->blockState));
4793 : Assert(s->state == TRANS_INPROGRESS);
4794 9162 : MemoryContextSwitchTo(CurTransactionContext);
4795 9162 : CommitSubTransaction();
4796 9162 : s = CurrentTransactionState; /* changed by pop */
4797 : Assert(s->state == TRANS_INPROGRESS);
4798 9162 : }
4799 :
4800 : /*
4801 : * RollbackAndReleaseCurrentSubTransaction
4802 : *
4803 : * ROLLBACK and RELEASE (ie, abort) the innermost subtransaction, regardless
4804 : * of its savepoint name (if any).
4805 : * NB: do NOT use CommitTransactionCommand/StartTransactionCommand with this.
4806 : */
4807 : void
4808 8210 : RollbackAndReleaseCurrentSubTransaction(void)
4809 : {
4810 8210 : TransactionState s = CurrentTransactionState;
4811 :
4812 : /*
4813 : * We do not check for parallel mode here. It's permissible to start and
4814 : * end "internal" subtransactions while in parallel mode, so long as no
4815 : * new XIDs or command IDs are assigned.
4816 : */
4817 :
4818 8210 : switch (s->blockState)
4819 : {
4820 : /* Must be in a subtransaction */
4821 8210 : case TBLOCK_SUBINPROGRESS:
4822 : case TBLOCK_SUBABORT:
4823 8210 : break;
4824 :
4825 : /* These cases are invalid. */
4826 0 : case TBLOCK_DEFAULT:
4827 : case TBLOCK_STARTED:
4828 : case TBLOCK_BEGIN:
4829 : case TBLOCK_IMPLICIT_INPROGRESS:
4830 : case TBLOCK_PARALLEL_INPROGRESS:
4831 : case TBLOCK_SUBBEGIN:
4832 : case TBLOCK_INPROGRESS:
4833 : case TBLOCK_END:
4834 : case TBLOCK_SUBRELEASE:
4835 : case TBLOCK_SUBCOMMIT:
4836 : case TBLOCK_ABORT:
4837 : case TBLOCK_ABORT_END:
4838 : case TBLOCK_SUBABORT_END:
4839 : case TBLOCK_ABORT_PENDING:
4840 : case TBLOCK_SUBABORT_PENDING:
4841 : case TBLOCK_SUBRESTART:
4842 : case TBLOCK_SUBABORT_RESTART:
4843 : case TBLOCK_PREPARE:
4844 0 : elog(FATAL, "RollbackAndReleaseCurrentSubTransaction: unexpected state %s",
4845 : BlockStateAsString(s->blockState));
4846 : break;
4847 : }
4848 :
4849 : /*
4850 : * Abort the current subtransaction, if needed.
4851 : */
4852 8210 : if (s->blockState == TBLOCK_SUBINPROGRESS)
4853 6356 : AbortSubTransaction();
4854 :
4855 : /* And clean it up, too */
4856 8210 : CleanupSubTransaction();
4857 :
4858 8210 : s = CurrentTransactionState; /* changed by pop */
4859 : Assert(s->blockState == TBLOCK_SUBINPROGRESS ||
4860 : s->blockState == TBLOCK_INPROGRESS ||
4861 : s->blockState == TBLOCK_IMPLICIT_INPROGRESS ||
4862 : s->blockState == TBLOCK_PARALLEL_INPROGRESS ||
4863 : s->blockState == TBLOCK_STARTED);
4864 8210 : }
4865 :
4866 : /*
4867 : * AbortOutOfAnyTransaction
4868 : *
4869 : * This routine is provided for error recovery purposes. It aborts any
4870 : * active transaction or transaction block, leaving the system in a known
4871 : * idle state.
4872 : */
4873 : void
4874 34916 : AbortOutOfAnyTransaction(void)
4875 : {
4876 34916 : TransactionState s = CurrentTransactionState;
4877 :
4878 : /* Ensure we're not running in a doomed memory context */
4879 34916 : AtAbort_Memory();
4880 :
4881 : /*
4882 : * Get out of any transaction or nested transaction
4883 : */
4884 : do
4885 : {
4886 34916 : switch (s->blockState)
4887 : {
4888 33792 : case TBLOCK_DEFAULT:
4889 33792 : if (s->state == TRANS_DEFAULT)
4890 : {
4891 : /* Not in a transaction, do nothing */
4892 : }
4893 : else
4894 : {
4895 : /*
4896 : * We can get here after an error during transaction start
4897 : * (state will be TRANS_START). Need to clean up the
4898 : * incompletely started transaction. First, adjust the
4899 : * low-level state to suppress warning message from
4900 : * AbortTransaction.
4901 : */
4902 0 : if (s->state == TRANS_START)
4903 0 : s->state = TRANS_INPROGRESS;
4904 0 : AbortTransaction();
4905 0 : CleanupTransaction();
4906 : }
4907 33792 : break;
4908 1102 : case TBLOCK_STARTED:
4909 : case TBLOCK_BEGIN:
4910 : case TBLOCK_INPROGRESS:
4911 : case TBLOCK_IMPLICIT_INPROGRESS:
4912 : case TBLOCK_PARALLEL_INPROGRESS:
4913 : case TBLOCK_END:
4914 : case TBLOCK_ABORT_PENDING:
4915 : case TBLOCK_PREPARE:
4916 : /* In a transaction, so clean up */
4917 1102 : AbortTransaction();
4918 1102 : CleanupTransaction();
4919 1102 : s->blockState = TBLOCK_DEFAULT;
4920 1102 : break;
4921 22 : case TBLOCK_ABORT:
4922 : case TBLOCK_ABORT_END:
4923 :
4924 : /*
4925 : * AbortTransaction is already done, still need Cleanup.
4926 : * However, if we failed partway through running ROLLBACK,
4927 : * there will be an active portal running that command, which
4928 : * we need to shut down before doing CleanupTransaction.
4929 : */
4930 22 : AtAbort_Portals();
4931 22 : CleanupTransaction();
4932 22 : s->blockState = TBLOCK_DEFAULT;
4933 22 : break;
4934 :
4935 : /*
4936 : * In a subtransaction, so clean it up and abort parent too
4937 : */
4938 0 : case TBLOCK_SUBBEGIN:
4939 : case TBLOCK_SUBINPROGRESS:
4940 : case TBLOCK_SUBRELEASE:
4941 : case TBLOCK_SUBCOMMIT:
4942 : case TBLOCK_SUBABORT_PENDING:
4943 : case TBLOCK_SUBRESTART:
4944 0 : AbortSubTransaction();
4945 0 : CleanupSubTransaction();
4946 0 : s = CurrentTransactionState; /* changed by pop */
4947 0 : break;
4948 :
4949 0 : case TBLOCK_SUBABORT:
4950 : case TBLOCK_SUBABORT_END:
4951 : case TBLOCK_SUBABORT_RESTART:
4952 : /* As above, but AbortSubTransaction already done */
4953 0 : if (s->curTransactionOwner)
4954 : {
4955 : /* As in TBLOCK_ABORT, might have a live portal to zap */
4956 0 : AtSubAbort_Portals(s->subTransactionId,
4957 0 : s->parent->subTransactionId,
4958 : s->curTransactionOwner,
4959 0 : s->parent->curTransactionOwner);
4960 : }
4961 0 : CleanupSubTransaction();
4962 0 : s = CurrentTransactionState; /* changed by pop */
4963 0 : break;
4964 : }
4965 34916 : } while (s->blockState != TBLOCK_DEFAULT);
4966 :
4967 : /* Should be out of all subxacts now */
4968 : Assert(s->parent == NULL);
4969 :
4970 : /*
4971 : * Revert to TopMemoryContext, to ensure we exit in a well-defined state
4972 : * whether there were any transactions to close or not. (Callers that
4973 : * don't intend to exit soon should switch to some other context to avoid
4974 : * long-term memory leaks.)
4975 : */
4976 34916 : MemoryContextSwitchTo(TopMemoryContext);
4977 34916 : }
4978 :
4979 : /*
4980 : * IsTransactionBlock --- are we within a transaction block?
4981 : */
4982 : bool
4983 603988 : IsTransactionBlock(void)
4984 : {
4985 603988 : TransactionState s = CurrentTransactionState;
4986 :
4987 603988 : if (s->blockState == TBLOCK_DEFAULT || s->blockState == TBLOCK_STARTED)
4988 474182 : return false;
4989 :
4990 129806 : return true;
4991 : }
4992 :
4993 : /*
4994 : * IsTransactionOrTransactionBlock --- are we within either a transaction
4995 : * or a transaction block? (The backend is only really "idle" when this
4996 : * returns false.)
4997 : *
4998 : * This should match up with IsTransactionBlock and IsTransactionState.
4999 : */
5000 : bool
5001 743602 : IsTransactionOrTransactionBlock(void)
5002 : {
5003 743602 : TransactionState s = CurrentTransactionState;
5004 :
5005 743602 : if (s->blockState == TBLOCK_DEFAULT)
5006 572036 : return false;
5007 :
5008 171566 : return true;
5009 : }
5010 :
5011 : /*
5012 : * TransactionBlockStatusCode - return status code to send in ReadyForQuery
5013 : */
5014 : char
5015 662156 : TransactionBlockStatusCode(void)
5016 : {
5017 662156 : TransactionState s = CurrentTransactionState;
5018 :
5019 662156 : switch (s->blockState)
5020 : {
5021 492406 : case TBLOCK_DEFAULT:
5022 : case TBLOCK_STARTED:
5023 492406 : return 'I'; /* idle --- not in transaction */
5024 167954 : case TBLOCK_BEGIN:
5025 : case TBLOCK_SUBBEGIN:
5026 : case TBLOCK_INPROGRESS:
5027 : case TBLOCK_IMPLICIT_INPROGRESS:
5028 : case TBLOCK_PARALLEL_INPROGRESS:
5029 : case TBLOCK_SUBINPROGRESS:
5030 : case TBLOCK_END:
5031 : case TBLOCK_SUBRELEASE:
5032 : case TBLOCK_SUBCOMMIT:
5033 : case TBLOCK_PREPARE:
5034 167954 : return 'T'; /* in transaction */
5035 1796 : case TBLOCK_ABORT:
5036 : case TBLOCK_SUBABORT:
5037 : case TBLOCK_ABORT_END:
5038 : case TBLOCK_SUBABORT_END:
5039 : case TBLOCK_ABORT_PENDING:
5040 : case TBLOCK_SUBABORT_PENDING:
5041 : case TBLOCK_SUBRESTART:
5042 : case TBLOCK_SUBABORT_RESTART:
5043 1796 : return 'E'; /* in failed transaction */
5044 : }
5045 :
5046 : /* should never get here */
5047 0 : elog(FATAL, "invalid transaction block state: %s",
5048 : BlockStateAsString(s->blockState));
5049 : return 0; /* keep compiler quiet */
5050 : }
5051 :
5052 : /*
5053 : * IsSubTransaction
5054 : */
5055 : bool
5056 1297976 : IsSubTransaction(void)
5057 : {
5058 1297976 : TransactionState s = CurrentTransactionState;
5059 :
5060 1297976 : if (s->nestingLevel >= 2)
5061 486 : return true;
5062 :
5063 1297490 : return false;
5064 : }
5065 :
5066 : /*
5067 : * StartSubTransaction
5068 : *
5069 : * If you're wondering why this is separate from PushTransaction: it's because
5070 : * we can't conveniently do this stuff right inside DefineSavepoint. The
5071 : * SAVEPOINT utility command will be executed inside a Portal, and if we
5072 : * muck with CurrentMemoryContext or CurrentResourceOwner then exit from
5073 : * the Portal will undo those settings. So we make DefineSavepoint just
5074 : * push a dummy transaction block, and when control returns to the main
5075 : * idle loop, CommitTransactionCommand will be called, and we'll come here
5076 : * to finish starting the subtransaction.
5077 : */
5078 : static void
5079 20052 : StartSubTransaction(void)
5080 : {
5081 20052 : TransactionState s = CurrentTransactionState;
5082 :
5083 20052 : if (s->state != TRANS_DEFAULT)
5084 0 : elog(WARNING, "StartSubTransaction while in %s state",
5085 : TransStateAsString(s->state));
5086 :
5087 20052 : s->state = TRANS_START;
5088 :
5089 : /*
5090 : * Initialize subsystems for new subtransaction
5091 : *
5092 : * must initialize resource-management stuff first
5093 : */
5094 20052 : AtSubStart_Memory();
5095 20052 : AtSubStart_ResourceOwner();
5096 20052 : AfterTriggerBeginSubXact();
5097 :
5098 20052 : s->state = TRANS_INPROGRESS;
5099 :
5100 : /*
5101 : * Call start-of-subxact callbacks
5102 : */
5103 20052 : CallSubXactCallbacks(SUBXACT_EVENT_START_SUB, s->subTransactionId,
5104 20052 : s->parent->subTransactionId);
5105 :
5106 20052 : ShowTransactionState("StartSubTransaction");
5107 20052 : }
5108 :
5109 : /*
5110 : * CommitSubTransaction
5111 : *
5112 : * The caller has to make sure to always reassign CurrentTransactionState
5113 : * if it has a local pointer to it after calling this function.
5114 : */
5115 : static void
5116 10686 : CommitSubTransaction(void)
5117 : {
5118 10686 : TransactionState s = CurrentTransactionState;
5119 :
5120 10686 : ShowTransactionState("CommitSubTransaction");
5121 :
5122 10686 : if (s->state != TRANS_INPROGRESS)
5123 0 : elog(WARNING, "CommitSubTransaction while in %s state",
5124 : TransStateAsString(s->state));
5125 :
5126 : /* Pre-commit processing goes here */
5127 :
5128 10686 : CallSubXactCallbacks(SUBXACT_EVENT_PRE_COMMIT_SUB, s->subTransactionId,
5129 10686 : s->parent->subTransactionId);
5130 :
5131 : /*
5132 : * If this subxact has started any unfinished parallel operation, clean up
5133 : * its workers and exit parallel mode. Warn about leaked resources.
5134 : */
5135 10686 : AtEOSubXact_Parallel(true, s->subTransactionId);
5136 10686 : if (s->parallelModeLevel != 0)
5137 : {
5138 0 : elog(WARNING, "parallelModeLevel is %d not 0 at end of subtransaction",
5139 : s->parallelModeLevel);
5140 0 : s->parallelModeLevel = 0;
5141 : }
5142 :
5143 : /* Do the actual "commit", such as it is */
5144 10686 : s->state = TRANS_COMMIT;
5145 :
5146 : /* Must CCI to ensure commands of subtransaction are seen as done */
5147 10686 : CommandCounterIncrement();
5148 :
5149 : /*
5150 : * Prior to 8.4 we marked subcommit in clog at this point. We now only
5151 : * perform that step, if required, as part of the atomic update of the
5152 : * whole transaction tree at top level commit or abort.
5153 : */
5154 :
5155 : /* Post-commit cleanup */
5156 10686 : if (FullTransactionIdIsValid(s->fullTransactionId))
5157 7366 : AtSubCommit_childXids();
5158 10686 : AfterTriggerEndSubXact(true);
5159 10686 : AtSubCommit_Portals(s->subTransactionId,
5160 10686 : s->parent->subTransactionId,
5161 10686 : s->parent->nestingLevel,
5162 10686 : s->parent->curTransactionOwner);
5163 10686 : AtEOSubXact_LargeObject(true, s->subTransactionId,
5164 10686 : s->parent->subTransactionId);
5165 10686 : AtSubCommit_Notify();
5166 :
5167 10686 : CallSubXactCallbacks(SUBXACT_EVENT_COMMIT_SUB, s->subTransactionId,
5168 10686 : s->parent->subTransactionId);
5169 :
5170 10686 : ResourceOwnerRelease(s->curTransactionOwner,
5171 : RESOURCE_RELEASE_BEFORE_LOCKS,
5172 : true, false);
5173 10686 : AtEOSubXact_RelationCache(true, s->subTransactionId,
5174 10686 : s->parent->subTransactionId);
5175 10686 : AtEOSubXact_TypeCache();
5176 10686 : AtEOSubXact_Inval(true);
5177 10686 : AtSubCommit_smgr();
5178 :
5179 : /*
5180 : * The only lock we actually release here is the subtransaction XID lock.
5181 : */
5182 10686 : CurrentResourceOwner = s->curTransactionOwner;
5183 10686 : if (FullTransactionIdIsValid(s->fullTransactionId))
5184 7366 : XactLockTableDelete(XidFromFullTransactionId(s->fullTransactionId));
5185 :
5186 : /*
5187 : * Other locks should get transferred to their parent resource owner.
5188 : */
5189 10686 : ResourceOwnerRelease(s->curTransactionOwner,
5190 : RESOURCE_RELEASE_LOCKS,
5191 : true, false);
5192 10686 : ResourceOwnerRelease(s->curTransactionOwner,
5193 : RESOURCE_RELEASE_AFTER_LOCKS,
5194 : true, false);
5195 :
5196 10686 : AtEOXact_GUC(true, s->gucNestLevel);
5197 10686 : AtEOSubXact_SPI(true, s->subTransactionId);
5198 10686 : AtEOSubXact_on_commit_actions(true, s->subTransactionId,
5199 10686 : s->parent->subTransactionId);
5200 10686 : AtEOSubXact_Namespace(true, s->subTransactionId,
5201 10686 : s->parent->subTransactionId);
5202 10686 : AtEOSubXact_Files(true, s->subTransactionId,
5203 10686 : s->parent->subTransactionId);
5204 10686 : AtEOSubXact_HashTables(true, s->nestingLevel);
5205 10686 : AtEOSubXact_PgStat(true, s->nestingLevel);
5206 10686 : AtSubCommit_Snapshot(s->nestingLevel);
5207 :
5208 : /*
5209 : * We need to restore the upper transaction's read-only state, in case the
5210 : * upper is read-write while the child is read-only; GUC will incorrectly
5211 : * think it should leave the child state in place.
5212 : */
5213 10686 : XactReadOnly = s->prevXactReadOnly;
5214 :
5215 10686 : CurrentResourceOwner = s->parent->curTransactionOwner;
5216 10686 : CurTransactionResourceOwner = s->parent->curTransactionOwner;
5217 10686 : ResourceOwnerDelete(s->curTransactionOwner);
5218 10686 : s->curTransactionOwner = NULL;
5219 :
5220 10686 : AtSubCommit_Memory();
5221 :
5222 10686 : s->state = TRANS_DEFAULT;
5223 :
5224 10686 : PopTransaction();
5225 10686 : }
5226 :
5227 : /*
5228 : * AbortSubTransaction
5229 : */
5230 : static void
5231 9366 : AbortSubTransaction(void)
5232 : {
5233 9366 : TransactionState s = CurrentTransactionState;
5234 :
5235 : /* Prevent cancel/die interrupt while cleaning up */
5236 9366 : HOLD_INTERRUPTS();
5237 :
5238 : /* Make sure we have a valid memory context and resource owner */
5239 9366 : AtSubAbort_Memory();
5240 9366 : AtSubAbort_ResourceOwner();
5241 :
5242 : /*
5243 : * Release any LW locks we might be holding as quickly as possible.
5244 : * (Regular locks, however, must be held till we finish aborting.)
5245 : * Releasing LW locks is critical since we might try to grab them again
5246 : * while cleaning up!
5247 : *
5248 : * FIXME This may be incorrect --- Are there some locks we should keep?
5249 : * Buffer locks, for example? I don't think so but I'm not sure.
5250 : */
5251 9366 : LWLockReleaseAll();
5252 :
5253 9366 : pgstat_report_wait_end();
5254 9366 : pgstat_progress_end_command();
5255 :
5256 9366 : pgaio_error_cleanup();
5257 :
5258 9366 : UnlockBuffers();
5259 :
5260 : /* Reset WAL record construction state */
5261 9366 : XLogResetInsertion();
5262 :
5263 : /* Cancel condition variable sleep */
5264 9366 : ConditionVariableCancelSleep();
5265 :
5266 : /*
5267 : * Also clean up any open wait for lock, since the lock manager will choke
5268 : * if we try to wait for another lock before doing this.
5269 : */
5270 9366 : LockErrorCleanup();
5271 :
5272 : /*
5273 : * If any timeout events are still active, make sure the timeout interrupt
5274 : * is scheduled. This covers possible loss of a timeout interrupt due to
5275 : * longjmp'ing out of the SIGINT handler (see notes in handle_sig_alarm).
5276 : * We delay this till after LockErrorCleanup so that we don't uselessly
5277 : * reschedule lock or deadlock check timeouts.
5278 : */
5279 9366 : reschedule_timeouts();
5280 :
5281 : /*
5282 : * Re-enable signals, in case we got here by longjmp'ing out of a signal
5283 : * handler. We do this fairly early in the sequence so that the timeout
5284 : * infrastructure will be functional if needed while aborting.
5285 : */
5286 9366 : sigprocmask(SIG_SETMASK, &UnBlockSig, NULL);
5287 :
5288 : /*
5289 : * check the current transaction state
5290 : */
5291 9366 : ShowTransactionState("AbortSubTransaction");
5292 :
5293 9366 : if (s->state != TRANS_INPROGRESS)
5294 0 : elog(WARNING, "AbortSubTransaction while in %s state",
5295 : TransStateAsString(s->state));
5296 :
5297 9366 : s->state = TRANS_ABORT;
5298 :
5299 : /*
5300 : * Reset user ID which might have been changed transiently. (See notes in
5301 : * AbortTransaction.)
5302 : */
5303 9366 : SetUserIdAndSecContext(s->prevUser, s->prevSecContext);
5304 :
5305 : /* Forget about any active REINDEX. */
5306 9366 : ResetReindexState(s->nestingLevel);
5307 :
5308 : /* Reset logical streaming state. */
5309 9366 : ResetLogicalStreamingState();
5310 :
5311 : /*
5312 : * No need for SnapBuildResetExportedSnapshotState() here, snapshot
5313 : * exports are not supported in subtransactions.
5314 : */
5315 :
5316 : /*
5317 : * If this subxact has started any unfinished parallel operation, clean up
5318 : * its workers and exit parallel mode. Don't warn about leaked resources.
5319 : */
5320 9366 : AtEOSubXact_Parallel(false, s->subTransactionId);
5321 9366 : s->parallelModeLevel = 0;
5322 :
5323 : /*
5324 : * We can skip all this stuff if the subxact failed before creating a
5325 : * ResourceOwner...
5326 : */
5327 9366 : if (s->curTransactionOwner)
5328 : {
5329 9366 : AfterTriggerEndSubXact(false);
5330 9366 : AtSubAbort_Portals(s->subTransactionId,
5331 9366 : s->parent->subTransactionId,
5332 : s->curTransactionOwner,
5333 9366 : s->parent->curTransactionOwner);
5334 9366 : AtEOSubXact_LargeObject(false, s->subTransactionId,
5335 9366 : s->parent->subTransactionId);
5336 9366 : AtSubAbort_Notify();
5337 :
5338 : /* Advertise the fact that we aborted in pg_xact. */
5339 9366 : (void) RecordTransactionAbort(true);
5340 :
5341 : /* Post-abort cleanup */
5342 9366 : if (FullTransactionIdIsValid(s->fullTransactionId))
5343 1298 : AtSubAbort_childXids();
5344 :
5345 9366 : CallSubXactCallbacks(SUBXACT_EVENT_ABORT_SUB, s->subTransactionId,
5346 9366 : s->parent->subTransactionId);
5347 :
5348 9366 : ResourceOwnerRelease(s->curTransactionOwner,
5349 : RESOURCE_RELEASE_BEFORE_LOCKS,
5350 : false, false);
5351 :
5352 9366 : AtEOXact_Aio(false);
5353 9366 : AtEOSubXact_RelationCache(false, s->subTransactionId,
5354 9366 : s->parent->subTransactionId);
5355 9366 : AtEOSubXact_TypeCache();
5356 9366 : AtEOSubXact_Inval(false);
5357 9366 : ResourceOwnerRelease(s->curTransactionOwner,
5358 : RESOURCE_RELEASE_LOCKS,
5359 : false, false);
5360 9366 : ResourceOwnerRelease(s->curTransactionOwner,
5361 : RESOURCE_RELEASE_AFTER_LOCKS,
5362 : false, false);
5363 9366 : AtSubAbort_smgr();
5364 :
5365 9366 : AtEOXact_GUC(false, s->gucNestLevel);
5366 9366 : AtEOSubXact_SPI(false, s->subTransactionId);
5367 9366 : AtEOSubXact_on_commit_actions(false, s->subTransactionId,
5368 9366 : s->parent->subTransactionId);
5369 9366 : AtEOSubXact_Namespace(false, s->subTransactionId,
5370 9366 : s->parent->subTransactionId);
5371 9366 : AtEOSubXact_Files(false, s->subTransactionId,
5372 9366 : s->parent->subTransactionId);
5373 9366 : AtEOSubXact_HashTables(false, s->nestingLevel);
5374 9366 : AtEOSubXact_PgStat(false, s->nestingLevel);
5375 9366 : AtSubAbort_Snapshot(s->nestingLevel);
5376 : }
5377 :
5378 : /*
5379 : * Restore the upper transaction's read-only state, too. This should be
5380 : * redundant with GUC's cleanup but we may as well do it for consistency
5381 : * with the commit case.
5382 : */
5383 9366 : XactReadOnly = s->prevXactReadOnly;
5384 :
5385 9366 : RESUME_INTERRUPTS();
5386 9366 : }
5387 :
5388 : /*
5389 : * CleanupSubTransaction
5390 : *
5391 : * The caller has to make sure to always reassign CurrentTransactionState
5392 : * if it has a local pointer to it after calling this function.
5393 : */
5394 : static void
5395 9366 : CleanupSubTransaction(void)
5396 : {
5397 9366 : TransactionState s = CurrentTransactionState;
5398 :
5399 9366 : ShowTransactionState("CleanupSubTransaction");
5400 :
5401 9366 : if (s->state != TRANS_ABORT)
5402 0 : elog(WARNING, "CleanupSubTransaction while in %s state",
5403 : TransStateAsString(s->state));
5404 :
5405 9366 : AtSubCleanup_Portals(s->subTransactionId);
5406 :
5407 9366 : CurrentResourceOwner = s->parent->curTransactionOwner;
5408 9366 : CurTransactionResourceOwner = s->parent->curTransactionOwner;
5409 9366 : if (s->curTransactionOwner)
5410 9366 : ResourceOwnerDelete(s->curTransactionOwner);
5411 9366 : s->curTransactionOwner = NULL;
5412 :
5413 9366 : AtSubCleanup_Memory();
5414 :
5415 9366 : s->state = TRANS_DEFAULT;
5416 :
5417 9366 : PopTransaction();
5418 9366 : }
5419 :
5420 : /*
5421 : * PushTransaction
5422 : * Create transaction state stack entry for a subtransaction
5423 : *
5424 : * The caller has to make sure to always reassign CurrentTransactionState
5425 : * if it has a local pointer to it after calling this function.
5426 : */
5427 : static void
5428 20052 : PushTransaction(void)
5429 : {
5430 20052 : TransactionState p = CurrentTransactionState;
5431 : TransactionState s;
5432 :
5433 : /*
5434 : * We keep subtransaction state nodes in TopTransactionContext.
5435 : */
5436 : s = (TransactionState)
5437 20052 : MemoryContextAllocZero(TopTransactionContext,
5438 : sizeof(TransactionStateData));
5439 :
5440 : /*
5441 : * Assign a subtransaction ID, watching out for counter wraparound.
5442 : */
5443 20052 : currentSubTransactionId += 1;
5444 20052 : if (currentSubTransactionId == InvalidSubTransactionId)
5445 : {
5446 0 : currentSubTransactionId -= 1;
5447 0 : pfree(s);
5448 0 : ereport(ERROR,
5449 : (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
5450 : errmsg("cannot have more than 2^32-1 subtransactions in a transaction")));
5451 : }
5452 :
5453 : /*
5454 : * We can now stack a minimally valid subtransaction without fear of
5455 : * failure.
5456 : */
5457 20052 : s->fullTransactionId = InvalidFullTransactionId; /* until assigned */
5458 20052 : s->subTransactionId = currentSubTransactionId;
5459 20052 : s->parent = p;
5460 20052 : s->nestingLevel = p->nestingLevel + 1;
5461 20052 : s->gucNestLevel = NewGUCNestLevel();
5462 20052 : s->savepointLevel = p->savepointLevel;
5463 20052 : s->state = TRANS_DEFAULT;
5464 20052 : s->blockState = TBLOCK_SUBBEGIN;
5465 20052 : GetUserIdAndSecContext(&s->prevUser, &s->prevSecContext);
5466 20052 : s->prevXactReadOnly = XactReadOnly;
5467 20052 : s->startedInRecovery = p->startedInRecovery;
5468 20052 : s->parallelModeLevel = 0;
5469 20052 : s->parallelChildXact = (p->parallelModeLevel != 0 || p->parallelChildXact);
5470 20052 : s->topXidLogged = false;
5471 :
5472 20052 : CurrentTransactionState = s;
5473 :
5474 : /*
5475 : * AbortSubTransaction and CleanupSubTransaction have to be able to cope
5476 : * with the subtransaction from here on out; in particular they should not
5477 : * assume that it necessarily has a transaction context, resource owner,
5478 : * or XID.
5479 : */
5480 20052 : }
5481 :
5482 : /*
5483 : * PopTransaction
5484 : * Pop back to parent transaction state
5485 : *
5486 : * The caller has to make sure to always reassign CurrentTransactionState
5487 : * if it has a local pointer to it after calling this function.
5488 : */
5489 : static void
5490 20052 : PopTransaction(void)
5491 : {
5492 20052 : TransactionState s = CurrentTransactionState;
5493 :
5494 20052 : if (s->state != TRANS_DEFAULT)
5495 0 : elog(WARNING, "PopTransaction while in %s state",
5496 : TransStateAsString(s->state));
5497 :
5498 20052 : if (s->parent == NULL)
5499 0 : elog(FATAL, "PopTransaction with no parent");
5500 :
5501 20052 : CurrentTransactionState = s->parent;
5502 :
5503 : /* Let's just make sure CurTransactionContext is good */
5504 20052 : CurTransactionContext = s->parent->curTransactionContext;
5505 20052 : MemoryContextSwitchTo(CurTransactionContext);
5506 :
5507 : /* Ditto for ResourceOwner links */
5508 20052 : CurTransactionResourceOwner = s->parent->curTransactionOwner;
5509 20052 : CurrentResourceOwner = s->parent->curTransactionOwner;
5510 :
5511 : /* Free the old child structure */
5512 20052 : if (s->name)
5513 3812 : pfree(s->name);
5514 20052 : pfree(s);
5515 20052 : }
5516 :
5517 : /*
5518 : * EstimateTransactionStateSpace
5519 : * Estimate the amount of space that will be needed by
5520 : * SerializeTransactionState. It would be OK to overestimate slightly,
5521 : * but it's simple for us to work out the precise value, so we do.
5522 : */
5523 : Size
5524 910 : EstimateTransactionStateSpace(void)
5525 : {
5526 : TransactionState s;
5527 910 : Size nxids = 0;
5528 910 : Size size = SerializedTransactionStateHeaderSize;
5529 :
5530 4358 : for (s = CurrentTransactionState; s != NULL; s = s->parent)
5531 : {
5532 3448 : if (FullTransactionIdIsValid(s->fullTransactionId))
5533 1976 : nxids = add_size(nxids, 1);
5534 3448 : nxids = add_size(nxids, s->nChildXids);
5535 : }
5536 :
5537 910 : return add_size(size, mul_size(sizeof(TransactionId), nxids));
5538 : }
5539 :
5540 : /*
5541 : * SerializeTransactionState
5542 : * Write out relevant details of our transaction state that will be
5543 : * needed by a parallel worker.
5544 : *
5545 : * We need to save and restore XactDeferrable, XactIsoLevel, and the XIDs
5546 : * associated with this transaction. These are serialized into a
5547 : * caller-supplied buffer big enough to hold the number of bytes reported by
5548 : * EstimateTransactionStateSpace(). We emit the XIDs in sorted order for the
5549 : * convenience of the receiving process.
5550 : */
5551 : void
5552 910 : SerializeTransactionState(Size maxsize, char *start_address)
5553 : {
5554 : TransactionState s;
5555 910 : Size nxids = 0;
5556 910 : Size i = 0;
5557 : TransactionId *workspace;
5558 : SerializedTransactionState *result;
5559 :
5560 910 : result = (SerializedTransactionState *) start_address;
5561 :
5562 910 : result->xactIsoLevel = XactIsoLevel;
5563 910 : result->xactDeferrable = XactDeferrable;
5564 910 : result->topFullTransactionId = XactTopFullTransactionId;
5565 910 : result->currentFullTransactionId =
5566 910 : CurrentTransactionState->fullTransactionId;
5567 910 : result->currentCommandId = currentCommandId;
5568 :
5569 : /*
5570 : * If we're running in a parallel worker and launching a parallel worker
5571 : * of our own, we can just pass along the information that was passed to
5572 : * us.
5573 : */
5574 910 : if (nParallelCurrentXids > 0)
5575 : {
5576 0 : result->nParallelCurrentXids = nParallelCurrentXids;
5577 0 : memcpy(&result->parallelCurrentXids[0], ParallelCurrentXids,
5578 : nParallelCurrentXids * sizeof(TransactionId));
5579 0 : return;
5580 : }
5581 :
5582 : /*
5583 : * OK, we need to generate a sorted list of XIDs that our workers should
5584 : * view as current. First, figure out how many there are.
5585 : */
5586 4358 : for (s = CurrentTransactionState; s != NULL; s = s->parent)
5587 : {
5588 3448 : if (FullTransactionIdIsValid(s->fullTransactionId))
5589 1976 : nxids = add_size(nxids, 1);
5590 3448 : nxids = add_size(nxids, s->nChildXids);
5591 : }
5592 : Assert(SerializedTransactionStateHeaderSize + nxids * sizeof(TransactionId)
5593 : <= maxsize);
5594 :
5595 : /* Copy them to our scratch space. */
5596 910 : workspace = palloc(nxids * sizeof(TransactionId));
5597 4358 : for (s = CurrentTransactionState; s != NULL; s = s->parent)
5598 : {
5599 3448 : if (FullTransactionIdIsValid(s->fullTransactionId))
5600 1976 : workspace[i++] = XidFromFullTransactionId(s->fullTransactionId);
5601 3448 : if (s->nChildXids > 0)
5602 0 : memcpy(&workspace[i], s->childXids,
5603 0 : s->nChildXids * sizeof(TransactionId));
5604 3448 : i += s->nChildXids;
5605 : }
5606 : Assert(i == nxids);
5607 :
5608 : /* Sort them. */
5609 910 : qsort(workspace, nxids, sizeof(TransactionId), xidComparator);
5610 :
5611 : /* Copy data into output area. */
5612 910 : result->nParallelCurrentXids = nxids;
5613 910 : memcpy(&result->parallelCurrentXids[0], workspace,
5614 : nxids * sizeof(TransactionId));
5615 : }
5616 :
5617 : /*
5618 : * StartParallelWorkerTransaction
5619 : * Start a parallel worker transaction, restoring the relevant
5620 : * transaction state serialized by SerializeTransactionState.
5621 : */
5622 : void
5623 2746 : StartParallelWorkerTransaction(char *tstatespace)
5624 : {
5625 : SerializedTransactionState *tstate;
5626 :
5627 : Assert(CurrentTransactionState->blockState == TBLOCK_DEFAULT);
5628 2746 : StartTransaction();
5629 :
5630 2746 : tstate = (SerializedTransactionState *) tstatespace;
5631 2746 : XactIsoLevel = tstate->xactIsoLevel;
5632 2746 : XactDeferrable = tstate->xactDeferrable;
5633 2746 : XactTopFullTransactionId = tstate->topFullTransactionId;
5634 2746 : CurrentTransactionState->fullTransactionId =
5635 : tstate->currentFullTransactionId;
5636 2746 : currentCommandId = tstate->currentCommandId;
5637 2746 : nParallelCurrentXids = tstate->nParallelCurrentXids;
5638 2746 : ParallelCurrentXids = &tstate->parallelCurrentXids[0];
5639 :
5640 2746 : CurrentTransactionState->blockState = TBLOCK_PARALLEL_INPROGRESS;
5641 2746 : }
5642 :
5643 : /*
5644 : * EndParallelWorkerTransaction
5645 : * End a parallel worker transaction.
5646 : */
5647 : void
5648 2734 : EndParallelWorkerTransaction(void)
5649 : {
5650 : Assert(CurrentTransactionState->blockState == TBLOCK_PARALLEL_INPROGRESS);
5651 2734 : CommitTransaction();
5652 2734 : CurrentTransactionState->blockState = TBLOCK_DEFAULT;
5653 2734 : }
5654 :
5655 : /*
5656 : * ShowTransactionState
5657 : * Debug support
5658 : */
5659 : static void
5660 2114608 : ShowTransactionState(const char *str)
5661 : {
5662 : /* skip work if message will definitely not be printed */
5663 2114608 : if (message_level_is_interesting(DEBUG5))
5664 0 : ShowTransactionStateRec(str, CurrentTransactionState);
5665 2114608 : }
5666 :
5667 : /*
5668 : * ShowTransactionStateRec
5669 : * Recursive subroutine for ShowTransactionState
5670 : */
5671 : static void
5672 0 : ShowTransactionStateRec(const char *str, TransactionState s)
5673 : {
5674 : StringInfoData buf;
5675 :
5676 0 : if (s->parent)
5677 : {
5678 : /*
5679 : * Since this function recurses, it could be driven to stack overflow.
5680 : * This is just a debugging aid, so we can leave out some details
5681 : * instead of erroring out with check_stack_depth().
5682 : */
5683 0 : if (stack_is_too_deep())
5684 0 : ereport(DEBUG5,
5685 : (errmsg_internal("%s(%d): parent omitted to avoid stack overflow",
5686 : str, s->nestingLevel)));
5687 : else
5688 0 : ShowTransactionStateRec(str, s->parent);
5689 : }
5690 :
5691 0 : initStringInfo(&buf);
5692 0 : if (s->nChildXids > 0)
5693 : {
5694 : int i;
5695 :
5696 0 : appendStringInfo(&buf, ", children: %u", s->childXids[0]);
5697 0 : for (i = 1; i < s->nChildXids; i++)
5698 0 : appendStringInfo(&buf, " %u", s->childXids[i]);
5699 : }
5700 0 : ereport(DEBUG5,
5701 : (errmsg_internal("%s(%d) name: %s; blockState: %s; state: %s, xid/subid/cid: %u/%u/%u%s%s",
5702 : str, s->nestingLevel,
5703 : PointerIsValid(s->name) ? s->name : "unnamed",
5704 : BlockStateAsString(s->blockState),
5705 : TransStateAsString(s->state),
5706 : (unsigned int) XidFromFullTransactionId(s->fullTransactionId),
5707 : (unsigned int) s->subTransactionId,
5708 : (unsigned int) currentCommandId,
5709 : currentCommandIdUsed ? " (used)" : "",
5710 : buf.data)));
5711 0 : pfree(buf.data);
5712 0 : }
5713 :
5714 : /*
5715 : * BlockStateAsString
5716 : * Debug support
5717 : */
5718 : static const char *
5719 0 : BlockStateAsString(TBlockState blockState)
5720 : {
5721 0 : switch (blockState)
5722 : {
5723 0 : case TBLOCK_DEFAULT:
5724 0 : return "DEFAULT";
5725 0 : case TBLOCK_STARTED:
5726 0 : return "STARTED";
5727 0 : case TBLOCK_BEGIN:
5728 0 : return "BEGIN";
5729 0 : case TBLOCK_INPROGRESS:
5730 0 : return "INPROGRESS";
5731 0 : case TBLOCK_IMPLICIT_INPROGRESS:
5732 0 : return "IMPLICIT_INPROGRESS";
5733 0 : case TBLOCK_PARALLEL_INPROGRESS:
5734 0 : return "PARALLEL_INPROGRESS";
5735 0 : case TBLOCK_END:
5736 0 : return "END";
5737 0 : case TBLOCK_ABORT:
5738 0 : return "ABORT";
5739 0 : case TBLOCK_ABORT_END:
5740 0 : return "ABORT_END";
5741 0 : case TBLOCK_ABORT_PENDING:
5742 0 : return "ABORT_PENDING";
5743 0 : case TBLOCK_PREPARE:
5744 0 : return "PREPARE";
5745 0 : case TBLOCK_SUBBEGIN:
5746 0 : return "SUBBEGIN";
5747 0 : case TBLOCK_SUBINPROGRESS:
5748 0 : return "SUBINPROGRESS";
5749 0 : case TBLOCK_SUBRELEASE:
5750 0 : return "SUBRELEASE";
5751 0 : case TBLOCK_SUBCOMMIT:
5752 0 : return "SUBCOMMIT";
5753 0 : case TBLOCK_SUBABORT:
5754 0 : return "SUBABORT";
5755 0 : case TBLOCK_SUBABORT_END:
5756 0 : return "SUBABORT_END";
5757 0 : case TBLOCK_SUBABORT_PENDING:
5758 0 : return "SUBABORT_PENDING";
5759 0 : case TBLOCK_SUBRESTART:
5760 0 : return "SUBRESTART";
5761 0 : case TBLOCK_SUBABORT_RESTART:
5762 0 : return "SUBABORT_RESTART";
5763 : }
5764 0 : return "UNRECOGNIZED";
5765 : }
5766 :
5767 : /*
5768 : * TransStateAsString
5769 : * Debug support
5770 : */
5771 : static const char *
5772 0 : TransStateAsString(TransState state)
5773 : {
5774 0 : switch (state)
5775 : {
5776 0 : case TRANS_DEFAULT:
5777 0 : return "DEFAULT";
5778 0 : case TRANS_START:
5779 0 : return "START";
5780 0 : case TRANS_INPROGRESS:
5781 0 : return "INPROGRESS";
5782 0 : case TRANS_COMMIT:
5783 0 : return "COMMIT";
5784 0 : case TRANS_ABORT:
5785 0 : return "ABORT";
5786 0 : case TRANS_PREPARE:
5787 0 : return "PREPARE";
5788 : }
5789 0 : return "UNRECOGNIZED";
5790 : }
5791 :
5792 : /*
5793 : * xactGetCommittedChildren
5794 : *
5795 : * Gets the list of committed children of the current transaction. The return
5796 : * value is the number of child transactions. *ptr is set to point to an
5797 : * array of TransactionIds. The array is allocated in TopTransactionContext;
5798 : * the caller should *not* pfree() it (this is a change from pre-8.4 code!).
5799 : * If there are no subxacts, *ptr is set to NULL.
5800 : */
5801 : int
5802 1016744 : xactGetCommittedChildren(TransactionId **ptr)
5803 : {
5804 1016744 : TransactionState s = CurrentTransactionState;
5805 :
5806 1016744 : if (s->nChildXids == 0)
5807 1015546 : *ptr = NULL;
5808 : else
5809 1198 : *ptr = s->childXids;
5810 :
5811 1016744 : return s->nChildXids;
5812 : }
5813 :
5814 : /*
5815 : * XLOG support routines
5816 : */
5817 :
5818 :
5819 : /*
5820 : * Log the commit record for a plain or twophase transaction commit.
5821 : *
5822 : * A 2pc commit will be emitted when twophase_xid is valid, a plain one
5823 : * otherwise.
5824 : */
5825 : XLogRecPtr
5826 253842 : XactLogCommitRecord(TimestampTz commit_time,
5827 : int nsubxacts, TransactionId *subxacts,
5828 : int nrels, RelFileLocator *rels,
5829 : int ndroppedstats, xl_xact_stats_item *droppedstats,
5830 : int nmsgs, SharedInvalidationMessage *msgs,
5831 : bool relcacheInval,
5832 : int xactflags, TransactionId twophase_xid,
5833 : const char *twophase_gid)
5834 : {
5835 : xl_xact_commit xlrec;
5836 : xl_xact_xinfo xl_xinfo;
5837 : xl_xact_dbinfo xl_dbinfo;
5838 : xl_xact_subxacts xl_subxacts;
5839 : xl_xact_relfilelocators xl_relfilelocators;
5840 : xl_xact_stats_items xl_dropped_stats;
5841 : xl_xact_invals xl_invals;
5842 : xl_xact_twophase xl_twophase;
5843 : xl_xact_origin xl_origin;
5844 : uint8 info;
5845 :
5846 : Assert(CritSectionCount > 0);
5847 :
5848 253842 : xl_xinfo.xinfo = 0;
5849 :
5850 : /* decide between a plain and 2pc commit */
5851 253842 : if (!TransactionIdIsValid(twophase_xid))
5852 253340 : info = XLOG_XACT_COMMIT;
5853 : else
5854 502 : info = XLOG_XACT_COMMIT_PREPARED;
5855 :
5856 : /* First figure out and collect all the information needed */
5857 :
5858 253842 : xlrec.xact_time = commit_time;
5859 :
5860 253842 : if (relcacheInval)
5861 7654 : xl_xinfo.xinfo |= XACT_COMPLETION_UPDATE_RELCACHE_FILE;
5862 253842 : if (forceSyncCommit)
5863 990 : xl_xinfo.xinfo |= XACT_COMPLETION_FORCE_SYNC_COMMIT;
5864 253842 : if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
5865 75844 : xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
5866 :
5867 : /*
5868 : * Check if the caller would like to ask standbys for immediate feedback
5869 : * once this commit is applied.
5870 : */
5871 253842 : if (synchronous_commit >= SYNCHRONOUS_COMMIT_REMOTE_APPLY)
5872 4 : xl_xinfo.xinfo |= XACT_COMPLETION_APPLY_FEEDBACK;
5873 :
5874 : /*
5875 : * Relcache invalidations requires information about the current database
5876 : * and so does logical decoding.
5877 : */
5878 253842 : if (nmsgs > 0 || XLogLogicalInfoActive())
5879 : {
5880 151070 : xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
5881 151070 : xl_dbinfo.dbId = MyDatabaseId;
5882 151070 : xl_dbinfo.tsId = MyDatabaseTableSpace;
5883 : }
5884 :
5885 253842 : if (nsubxacts > 0)
5886 : {
5887 1008 : xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
5888 1008 : xl_subxacts.nsubxacts = nsubxacts;
5889 : }
5890 :
5891 253842 : if (nrels > 0)
5892 : {
5893 19550 : xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
5894 19550 : xl_relfilelocators.nrels = nrels;
5895 19550 : info |= XLR_SPECIAL_REL_UPDATE;
5896 : }
5897 :
5898 253842 : if (ndroppedstats > 0)
5899 : {
5900 21170 : xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
5901 21170 : xl_dropped_stats.nitems = ndroppedstats;
5902 : }
5903 :
5904 253842 : if (nmsgs > 0)
5905 : {
5906 149358 : xl_xinfo.xinfo |= XACT_XINFO_HAS_INVALS;
5907 149358 : xl_invals.nmsgs = nmsgs;
5908 : }
5909 :
5910 253842 : if (TransactionIdIsValid(twophase_xid))
5911 : {
5912 502 : xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
5913 502 : xl_twophase.xid = twophase_xid;
5914 : Assert(twophase_gid != NULL);
5915 :
5916 502 : if (XLogLogicalInfoActive())
5917 76 : xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
5918 : }
5919 :
5920 : /* dump transaction origin information */
5921 253842 : if (replorigin_session_origin != InvalidRepOriginId)
5922 : {
5923 2028 : xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
5924 :
5925 2028 : xl_origin.origin_lsn = replorigin_session_origin_lsn;
5926 2028 : xl_origin.origin_timestamp = replorigin_session_origin_timestamp;
5927 : }
5928 :
5929 253842 : if (xl_xinfo.xinfo != 0)
5930 163358 : info |= XLOG_XACT_HAS_INFO;
5931 :
5932 : /* Then include all the collected data into the commit record. */
5933 :
5934 253842 : XLogBeginInsert();
5935 :
5936 253842 : XLogRegisterData(&xlrec, sizeof(xl_xact_commit));
5937 :
5938 253842 : if (xl_xinfo.xinfo != 0)
5939 163358 : XLogRegisterData(&xl_xinfo.xinfo, sizeof(xl_xinfo.xinfo));
5940 :
5941 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
5942 151070 : XLogRegisterData(&xl_dbinfo, sizeof(xl_dbinfo));
5943 :
5944 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
5945 : {
5946 1008 : XLogRegisterData(&xl_subxacts,
5947 : MinSizeOfXactSubxacts);
5948 1008 : XLogRegisterData(subxacts,
5949 : nsubxacts * sizeof(TransactionId));
5950 : }
5951 :
5952 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
5953 : {
5954 19550 : XLogRegisterData(&xl_relfilelocators,
5955 : MinSizeOfXactRelfileLocators);
5956 19550 : XLogRegisterData(rels,
5957 : nrels * sizeof(RelFileLocator));
5958 : }
5959 :
5960 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
5961 : {
5962 21170 : XLogRegisterData(&xl_dropped_stats,
5963 : MinSizeOfXactStatsItems);
5964 21170 : XLogRegisterData(droppedstats,
5965 : ndroppedstats * sizeof(xl_xact_stats_item));
5966 : }
5967 :
5968 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_INVALS)
5969 : {
5970 149358 : XLogRegisterData(&xl_invals, MinSizeOfXactInvals);
5971 149358 : XLogRegisterData(msgs,
5972 : nmsgs * sizeof(SharedInvalidationMessage));
5973 : }
5974 :
5975 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
5976 : {
5977 502 : XLogRegisterData(&xl_twophase, sizeof(xl_xact_twophase));
5978 502 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
5979 76 : XLogRegisterData(twophase_gid, strlen(twophase_gid) + 1);
5980 : }
5981 :
5982 253842 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
5983 2028 : XLogRegisterData(&xl_origin, sizeof(xl_xact_origin));
5984 :
5985 : /* we allow filtering by xacts */
5986 253842 : XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
5987 :
5988 253842 : return XLogInsert(RM_XACT_ID, info);
5989 : }
5990 :
5991 : /*
5992 : * Log the commit record for a plain or twophase transaction abort.
5993 : *
5994 : * A 2pc abort will be emitted when twophase_xid is valid, a plain one
5995 : * otherwise.
5996 : */
5997 : XLogRecPtr
5998 11908 : XactLogAbortRecord(TimestampTz abort_time,
5999 : int nsubxacts, TransactionId *subxacts,
6000 : int nrels, RelFileLocator *rels,
6001 : int ndroppedstats, xl_xact_stats_item *droppedstats,
6002 : int xactflags, TransactionId twophase_xid,
6003 : const char *twophase_gid)
6004 : {
6005 : xl_xact_abort xlrec;
6006 : xl_xact_xinfo xl_xinfo;
6007 : xl_xact_subxacts xl_subxacts;
6008 : xl_xact_relfilelocators xl_relfilelocators;
6009 : xl_xact_stats_items xl_dropped_stats;
6010 : xl_xact_twophase xl_twophase;
6011 : xl_xact_dbinfo xl_dbinfo;
6012 : xl_xact_origin xl_origin;
6013 :
6014 : uint8 info;
6015 :
6016 : Assert(CritSectionCount > 0);
6017 :
6018 11908 : xl_xinfo.xinfo = 0;
6019 :
6020 : /* decide between a plain and 2pc abort */
6021 11908 : if (!TransactionIdIsValid(twophase_xid))
6022 11832 : info = XLOG_XACT_ABORT;
6023 : else
6024 76 : info = XLOG_XACT_ABORT_PREPARED;
6025 :
6026 :
6027 : /* First figure out and collect all the information needed */
6028 :
6029 11908 : xlrec.xact_time = abort_time;
6030 :
6031 11908 : if ((xactflags & XACT_FLAGS_ACQUIREDACCESSEXCLUSIVELOCK))
6032 4878 : xl_xinfo.xinfo |= XACT_XINFO_HAS_AE_LOCKS;
6033 :
6034 11908 : if (nsubxacts > 0)
6035 : {
6036 198 : xl_xinfo.xinfo |= XACT_XINFO_HAS_SUBXACTS;
6037 198 : xl_subxacts.nsubxacts = nsubxacts;
6038 : }
6039 :
6040 11908 : if (nrels > 0)
6041 : {
6042 2006 : xl_xinfo.xinfo |= XACT_XINFO_HAS_RELFILELOCATORS;
6043 2006 : xl_relfilelocators.nrels = nrels;
6044 2006 : info |= XLR_SPECIAL_REL_UPDATE;
6045 : }
6046 :
6047 11908 : if (ndroppedstats > 0)
6048 : {
6049 2740 : xl_xinfo.xinfo |= XACT_XINFO_HAS_DROPPED_STATS;
6050 2740 : xl_dropped_stats.nitems = ndroppedstats;
6051 : }
6052 :
6053 11908 : if (TransactionIdIsValid(twophase_xid))
6054 : {
6055 76 : xl_xinfo.xinfo |= XACT_XINFO_HAS_TWOPHASE;
6056 76 : xl_twophase.xid = twophase_xid;
6057 : Assert(twophase_gid != NULL);
6058 :
6059 76 : if (XLogLogicalInfoActive())
6060 26 : xl_xinfo.xinfo |= XACT_XINFO_HAS_GID;
6061 : }
6062 :
6063 11908 : if (TransactionIdIsValid(twophase_xid) && XLogLogicalInfoActive())
6064 : {
6065 26 : xl_xinfo.xinfo |= XACT_XINFO_HAS_DBINFO;
6066 26 : xl_dbinfo.dbId = MyDatabaseId;
6067 26 : xl_dbinfo.tsId = MyDatabaseTableSpace;
6068 : }
6069 :
6070 : /*
6071 : * Dump transaction origin information. We need this during recovery to
6072 : * update the replication origin progress.
6073 : */
6074 11908 : if (replorigin_session_origin != InvalidRepOriginId)
6075 : {
6076 66 : xl_xinfo.xinfo |= XACT_XINFO_HAS_ORIGIN;
6077 :
6078 66 : xl_origin.origin_lsn = replorigin_session_origin_lsn;
6079 66 : xl_origin.origin_timestamp = replorigin_session_origin_timestamp;
6080 : }
6081 :
6082 11908 : if (xl_xinfo.xinfo != 0)
6083 6124 : info |= XLOG_XACT_HAS_INFO;
6084 :
6085 : /* Then include all the collected data into the abort record. */
6086 :
6087 11908 : XLogBeginInsert();
6088 :
6089 11908 : XLogRegisterData(&xlrec, MinSizeOfXactAbort);
6090 :
6091 11908 : if (xl_xinfo.xinfo != 0)
6092 6124 : XLogRegisterData(&xl_xinfo, sizeof(xl_xinfo));
6093 :
6094 11908 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
6095 26 : XLogRegisterData(&xl_dbinfo, sizeof(xl_dbinfo));
6096 :
6097 11908 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
6098 : {
6099 198 : XLogRegisterData(&xl_subxacts,
6100 : MinSizeOfXactSubxacts);
6101 198 : XLogRegisterData(subxacts,
6102 : nsubxacts * sizeof(TransactionId));
6103 : }
6104 :
6105 11908 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
6106 : {
6107 2006 : XLogRegisterData(&xl_relfilelocators,
6108 : MinSizeOfXactRelfileLocators);
6109 2006 : XLogRegisterData(rels,
6110 : nrels * sizeof(RelFileLocator));
6111 : }
6112 :
6113 11908 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
6114 : {
6115 2740 : XLogRegisterData(&xl_dropped_stats,
6116 : MinSizeOfXactStatsItems);
6117 2740 : XLogRegisterData(droppedstats,
6118 : ndroppedstats * sizeof(xl_xact_stats_item));
6119 : }
6120 :
6121 11908 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
6122 : {
6123 76 : XLogRegisterData(&xl_twophase, sizeof(xl_xact_twophase));
6124 76 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
6125 26 : XLogRegisterData(twophase_gid, strlen(twophase_gid) + 1);
6126 : }
6127 :
6128 11908 : if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
6129 66 : XLogRegisterData(&xl_origin, sizeof(xl_xact_origin));
6130 :
6131 : /* Include the replication origin */
6132 11908 : XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
6133 :
6134 11908 : return XLogInsert(RM_XACT_ID, info);
6135 : }
6136 :
6137 : /*
6138 : * Before 9.0 this was a fairly short function, but now it performs many
6139 : * actions for which the order of execution is critical.
6140 : */
6141 : static void
6142 43318 : xact_redo_commit(xl_xact_parsed_commit *parsed,
6143 : TransactionId xid,
6144 : XLogRecPtr lsn,
6145 : RepOriginId origin_id)
6146 : {
6147 : TransactionId max_xid;
6148 : TimestampTz commit_time;
6149 :
6150 : Assert(TransactionIdIsValid(xid));
6151 :
6152 43318 : max_xid = TransactionIdLatest(xid, parsed->nsubxacts, parsed->subxacts);
6153 :
6154 : /* Make sure nextXid is beyond any XID mentioned in the record. */
6155 43318 : AdvanceNextFullTransactionIdPastXid(max_xid);
6156 :
6157 : Assert(((parsed->xinfo & XACT_XINFO_HAS_ORIGIN) == 0) ==
6158 : (origin_id == InvalidRepOriginId));
6159 :
6160 43318 : if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
6161 40 : commit_time = parsed->origin_timestamp;
6162 : else
6163 43278 : commit_time = parsed->xact_time;
6164 :
6165 : /* Set the transaction commit timestamp and metadata */
6166 43318 : TransactionTreeSetCommitTsData(xid, parsed->nsubxacts, parsed->subxacts,
6167 : commit_time, origin_id);
6168 :
6169 43318 : if (standbyState == STANDBY_DISABLED)
6170 : {
6171 : /*
6172 : * Mark the transaction committed in pg_xact.
6173 : */
6174 4452 : TransactionIdCommitTree(xid, parsed->nsubxacts, parsed->subxacts);
6175 : }
6176 : else
6177 : {
6178 : /*
6179 : * If a transaction completion record arrives that has as-yet
6180 : * unobserved subtransactions then this will not have been fully
6181 : * handled by the call to RecordKnownAssignedTransactionIds() in the
6182 : * main recovery loop in xlog.c. So we need to do bookkeeping again to
6183 : * cover that case. This is confusing and it is easy to think this
6184 : * call is irrelevant, which has happened three times in development
6185 : * already. Leave it in.
6186 : */
6187 38866 : RecordKnownAssignedTransactionIds(max_xid);
6188 :
6189 : /*
6190 : * Mark the transaction committed in pg_xact. We use async commit
6191 : * protocol during recovery to provide information on database
6192 : * consistency for when users try to set hint bits. It is important
6193 : * that we do not set hint bits until the minRecoveryPoint is past
6194 : * this commit record. This ensures that if we crash we don't see hint
6195 : * bits set on changes made by transactions that haven't yet
6196 : * recovered. It's unlikely but it's good to be safe.
6197 : */
6198 38866 : TransactionIdAsyncCommitTree(xid, parsed->nsubxacts, parsed->subxacts, lsn);
6199 :
6200 : /*
6201 : * We must mark clog before we update the ProcArray.
6202 : */
6203 38866 : ExpireTreeKnownAssignedTransactionIds(xid, parsed->nsubxacts, parsed->subxacts, max_xid);
6204 :
6205 : /*
6206 : * Send any cache invalidations attached to the commit. We must
6207 : * maintain the same order of invalidation then release locks as
6208 : * occurs in CommitTransaction().
6209 : */
6210 38866 : ProcessCommittedInvalidationMessages(parsed->msgs, parsed->nmsgs,
6211 38866 : XactCompletionRelcacheInitFileInval(parsed->xinfo),
6212 : parsed->dbId, parsed->tsId);
6213 :
6214 : /*
6215 : * Release locks, if any. We do this for both two phase and normal one
6216 : * phase transactions. In effect we are ignoring the prepare phase and
6217 : * just going straight to lock release.
6218 : */
6219 38866 : if (parsed->xinfo & XACT_XINFO_HAS_AE_LOCKS)
6220 18882 : StandbyReleaseLockTree(xid, parsed->nsubxacts, parsed->subxacts);
6221 : }
6222 :
6223 43318 : if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
6224 : {
6225 : /* recover apply progress */
6226 40 : replorigin_advance(origin_id, parsed->origin_lsn, lsn,
6227 : false /* backward */ , false /* WAL */ );
6228 : }
6229 :
6230 : /* Make sure files supposed to be dropped are dropped */
6231 43318 : if (parsed->nrels > 0)
6232 : {
6233 : /*
6234 : * First update minimum recovery point to cover this WAL record. Once
6235 : * a relation is deleted, there's no going back. The buffer manager
6236 : * enforces the WAL-first rule for normal updates to relation files,
6237 : * so that the minimum recovery point is always updated before the
6238 : * corresponding change in the data file is flushed to disk, but we
6239 : * have to do the same here since we're bypassing the buffer manager.
6240 : *
6241 : * Doing this before deleting the files means that if a deletion fails
6242 : * for some reason, you cannot start up the system even after restart,
6243 : * until you fix the underlying situation so that the deletion will
6244 : * succeed. Alternatively, we could update the minimum recovery point
6245 : * after deletion, but that would leave a small window where the
6246 : * WAL-first rule would be violated.
6247 : */
6248 4004 : XLogFlush(lsn);
6249 :
6250 : /* Make sure files supposed to be dropped are dropped */
6251 4004 : DropRelationFiles(parsed->xlocators, parsed->nrels, true);
6252 : }
6253 :
6254 43318 : if (parsed->nstats > 0)
6255 : {
6256 : /* see equivalent call for relations above */
6257 5218 : XLogFlush(lsn);
6258 :
6259 5218 : pgstat_execute_transactional_drops(parsed->nstats, parsed->stats, true);
6260 : }
6261 :
6262 : /*
6263 : * We issue an XLogFlush() for the same reason we emit ForceSyncCommit()
6264 : * in normal operation. For example, in CREATE DATABASE, we copy all files
6265 : * from the template database, and then commit the transaction. If we
6266 : * crash after all the files have been copied but before the commit, you
6267 : * have files in the data directory without an entry in pg_database. To
6268 : * minimize the window for that, we use ForceSyncCommit() to rush the
6269 : * commit record to disk as quick as possible. We have the same window
6270 : * during recovery, and forcing an XLogFlush() (which updates
6271 : * minRecoveryPoint during recovery) helps to reduce that problem window,
6272 : * for any user that requested ForceSyncCommit().
6273 : */
6274 43318 : if (XactCompletionForceSyncCommit(parsed->xinfo))
6275 96 : XLogFlush(lsn);
6276 :
6277 : /*
6278 : * If asked by the primary (because someone is waiting for a synchronous
6279 : * commit = remote_apply), we will need to ask walreceiver to send a reply
6280 : * immediately.
6281 : */
6282 43318 : if (XactCompletionApplyFeedback(parsed->xinfo))
6283 4 : XLogRequestWalReceiverReply();
6284 43318 : }
6285 :
6286 : /*
6287 : * Be careful with the order of execution, as with xact_redo_commit().
6288 : * The two functions are similar but differ in key places.
6289 : *
6290 : * Note also that an abort can be for a subtransaction and its children,
6291 : * not just for a top level abort. That means we have to consider
6292 : * topxid != xid, whereas in commit we would find topxid == xid always
6293 : * because subtransaction commit is never WAL logged.
6294 : */
6295 : static void
6296 3594 : xact_redo_abort(xl_xact_parsed_abort *parsed, TransactionId xid,
6297 : XLogRecPtr lsn, RepOriginId origin_id)
6298 : {
6299 : TransactionId max_xid;
6300 :
6301 : Assert(TransactionIdIsValid(xid));
6302 :
6303 : /* Make sure nextXid is beyond any XID mentioned in the record. */
6304 3594 : max_xid = TransactionIdLatest(xid,
6305 : parsed->nsubxacts,
6306 3594 : parsed->subxacts);
6307 3594 : AdvanceNextFullTransactionIdPastXid(max_xid);
6308 :
6309 3594 : if (standbyState == STANDBY_DISABLED)
6310 : {
6311 : /* Mark the transaction aborted in pg_xact, no need for async stuff */
6312 40 : TransactionIdAbortTree(xid, parsed->nsubxacts, parsed->subxacts);
6313 : }
6314 : else
6315 : {
6316 : /*
6317 : * If a transaction completion record arrives that has as-yet
6318 : * unobserved subtransactions then this will not have been fully
6319 : * handled by the call to RecordKnownAssignedTransactionIds() in the
6320 : * main recovery loop in xlog.c. So we need to do bookkeeping again to
6321 : * cover that case. This is confusing and it is easy to think this
6322 : * call is irrelevant, which has happened three times in development
6323 : * already. Leave it in.
6324 : */
6325 3554 : RecordKnownAssignedTransactionIds(max_xid);
6326 :
6327 : /* Mark the transaction aborted in pg_xact, no need for async stuff */
6328 3554 : TransactionIdAbortTree(xid, parsed->nsubxacts, parsed->subxacts);
6329 :
6330 : /*
6331 : * We must update the ProcArray after we have marked clog.
6332 : */
6333 3554 : ExpireTreeKnownAssignedTransactionIds(xid, parsed->nsubxacts, parsed->subxacts, max_xid);
6334 :
6335 : /*
6336 : * There are no invalidation messages to send or undo.
6337 : */
6338 :
6339 : /*
6340 : * Release locks, if any. There are no invalidations to send.
6341 : */
6342 3554 : if (parsed->xinfo & XACT_XINFO_HAS_AE_LOCKS)
6343 2228 : StandbyReleaseLockTree(xid, parsed->nsubxacts, parsed->subxacts);
6344 : }
6345 :
6346 3594 : if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
6347 : {
6348 : /* recover apply progress */
6349 10 : replorigin_advance(origin_id, parsed->origin_lsn, lsn,
6350 : false /* backward */ , false /* WAL */ );
6351 : }
6352 :
6353 : /* Make sure files supposed to be dropped are dropped */
6354 3594 : if (parsed->nrels > 0)
6355 : {
6356 : /*
6357 : * See comments about update of minimum recovery point on truncation,
6358 : * in xact_redo_commit().
6359 : */
6360 632 : XLogFlush(lsn);
6361 :
6362 632 : DropRelationFiles(parsed->xlocators, parsed->nrels, true);
6363 : }
6364 :
6365 3594 : if (parsed->nstats > 0)
6366 : {
6367 : /* see equivalent call for relations above */
6368 836 : XLogFlush(lsn);
6369 :
6370 836 : pgstat_execute_transactional_drops(parsed->nstats, parsed->stats, true);
6371 : }
6372 3594 : }
6373 :
6374 : void
6375 47590 : xact_redo(XLogReaderState *record)
6376 : {
6377 47590 : uint8 info = XLogRecGetInfo(record) & XLOG_XACT_OPMASK;
6378 :
6379 : /* Backup blocks are not used in xact records */
6380 : Assert(!XLogRecHasAnyBlockRefs(record));
6381 :
6382 47590 : if (info == XLOG_XACT_COMMIT)
6383 : {
6384 43230 : xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6385 : xl_xact_parsed_commit parsed;
6386 :
6387 43230 : ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6388 43230 : xact_redo_commit(&parsed, XLogRecGetXid(record),
6389 43230 : record->EndRecPtr, XLogRecGetOrigin(record));
6390 : }
6391 4360 : else if (info == XLOG_XACT_COMMIT_PREPARED)
6392 : {
6393 88 : xl_xact_commit *xlrec = (xl_xact_commit *) XLogRecGetData(record);
6394 : xl_xact_parsed_commit parsed;
6395 :
6396 88 : ParseCommitRecord(XLogRecGetInfo(record), xlrec, &parsed);
6397 88 : xact_redo_commit(&parsed, parsed.twophase_xid,
6398 88 : record->EndRecPtr, XLogRecGetOrigin(record));
6399 :
6400 : /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6401 88 : LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6402 88 : PrepareRedoRemove(parsed.twophase_xid, false);
6403 88 : LWLockRelease(TwoPhaseStateLock);
6404 : }
6405 4272 : else if (info == XLOG_XACT_ABORT)
6406 : {
6407 3552 : xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6408 : xl_xact_parsed_abort parsed;
6409 :
6410 3552 : ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6411 3552 : xact_redo_abort(&parsed, XLogRecGetXid(record),
6412 3552 : record->EndRecPtr, XLogRecGetOrigin(record));
6413 : }
6414 720 : else if (info == XLOG_XACT_ABORT_PREPARED)
6415 : {
6416 42 : xl_xact_abort *xlrec = (xl_xact_abort *) XLogRecGetData(record);
6417 : xl_xact_parsed_abort parsed;
6418 :
6419 42 : ParseAbortRecord(XLogRecGetInfo(record), xlrec, &parsed);
6420 42 : xact_redo_abort(&parsed, parsed.twophase_xid,
6421 42 : record->EndRecPtr, XLogRecGetOrigin(record));
6422 :
6423 : /* Delete TwoPhaseState gxact entry and/or 2PC file. */
6424 42 : LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6425 42 : PrepareRedoRemove(parsed.twophase_xid, false);
6426 42 : LWLockRelease(TwoPhaseStateLock);
6427 : }
6428 678 : else if (info == XLOG_XACT_PREPARE)
6429 : {
6430 : /*
6431 : * Store xid and start/end pointers of the WAL record in TwoPhaseState
6432 : * gxact entry.
6433 : */
6434 152 : LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
6435 152 : PrepareRedoAdd(InvalidFullTransactionId,
6436 152 : XLogRecGetData(record),
6437 : record->ReadRecPtr,
6438 : record->EndRecPtr,
6439 152 : XLogRecGetOrigin(record));
6440 152 : LWLockRelease(TwoPhaseStateLock);
6441 : }
6442 526 : else if (info == XLOG_XACT_ASSIGNMENT)
6443 : {
6444 42 : xl_xact_assignment *xlrec = (xl_xact_assignment *) XLogRecGetData(record);
6445 :
6446 42 : if (standbyState >= STANDBY_INITIALIZED)
6447 42 : ProcArrayApplyXidAssignment(xlrec->xtop,
6448 42 : xlrec->nsubxacts, xlrec->xsub);
6449 : }
6450 484 : else if (info == XLOG_XACT_INVALIDATIONS)
6451 : {
6452 : /*
6453 : * XXX we do ignore this for now, what matters are invalidations
6454 : * written into the commit record.
6455 : */
6456 : }
6457 : else
6458 0 : elog(PANIC, "xact_redo: unknown op code %u", info);
6459 47590 : }
|
