#include "access/transam.h"
#include "utils/relcache.h"
#include "utils/resowner.h"
#include "utils/snapshot.h"

Include dependency graph for snapmgr.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	OLD_SNAPSHOT_PADDING_ENTRIES 10

#define	OLD_SNAPSHOT_TIME_MAP_ENTRIES (old_snapshot_threshold + OLD_SNAPSHOT_PADDING_ENTRIES)

#define	RelationAllowsEarlyPruning(rel)

#define	EarlyPruningEnabled(rel) (old_snapshot_threshold >= 0 && RelationAllowsEarlyPruning(rel))

#define	SnapshotSelf (&SnapshotSelfData)

#define	SnapshotAny (&SnapshotAnyData)

#define	InitDirtySnapshot(snapshotdata) ((snapshotdata).snapshot_type = SNAPSHOT_DIRTY)

#define	InitNonVacuumableSnapshot(snapshotdata, vistestp)

#define	InitToastSnapshot(snapshotdata, l, w)

#define	IsMVCCSnapshot(snapshot)

Typedefs
typedef struct GlobalVisState	GlobalVisState

Functions
Size	SnapMgrShmemSize (void)

void	SnapMgrInit (void)

TimestampTz	GetSnapshotCurrentTimestamp (void)

TimestampTz	GetOldSnapshotThresholdTimestamp (void)

void	SnapshotTooOldMagicForTest (void)

static bool	OldSnapshotThresholdActive (void)

Snapshot	GetTransactionSnapshot (void)

Snapshot	GetLatestSnapshot (void)

void	SnapshotSetCommandId (CommandId curcid)

Snapshot	GetOldestSnapshot (void)

Snapshot	GetCatalogSnapshot (Oid relid)

Snapshot	GetNonHistoricCatalogSnapshot (Oid relid)

void	InvalidateCatalogSnapshot (void)

void	InvalidateCatalogSnapshotConditionally (void)

void	PushActiveSnapshot (Snapshot snapshot)

void	PushActiveSnapshotWithLevel (Snapshot snapshot, int snap_level)

void	PushCopiedSnapshot (Snapshot snapshot)

void	UpdateActiveSnapshotCommandId (void)

void	PopActiveSnapshot (void)

Snapshot	GetActiveSnapshot (void)

bool	ActiveSnapshotSet (void)

Snapshot	RegisterSnapshot (Snapshot snapshot)

void	UnregisterSnapshot (Snapshot snapshot)

Snapshot	RegisterSnapshotOnOwner (Snapshot snapshot, ResourceOwner owner)

void	UnregisterSnapshotFromOwner (Snapshot snapshot, ResourceOwner owner)

void	AtSubCommit_Snapshot (int level)

void	AtSubAbort_Snapshot (int level)

void	AtEOXact_Snapshot (bool isCommit, bool resetXmin)

void	ImportSnapshot (const char *idstr)

bool	XactHasExportedSnapshots (void)

void	DeleteAllExportedSnapshotFiles (void)

void	WaitForOlderSnapshots (TransactionId limitXmin, bool progress)

bool	ThereAreNoPriorRegisteredSnapshots (void)

bool	HaveRegisteredOrActiveSnapshot (void)

bool	TransactionIdLimitedForOldSnapshots (TransactionId recentXmin, Relation relation, TransactionId limit_xid, TimestampTz limit_ts)

void	SetOldSnapshotThresholdTimestamp (TimestampTz ts, TransactionId xlimit)

void	MaintainOldSnapshotTimeMapping (TimestampTz whenTaken, TransactionId xmin)

char *	ExportSnapshot (Snapshot snapshot)

GlobalVisState *	GlobalVisTestFor (Relation rel)

bool	GlobalVisTestIsRemovableXid (GlobalVisState *state, TransactionId xid)

bool	GlobalVisTestIsRemovableFullXid (GlobalVisState *state, FullTransactionId fxid)

FullTransactionId	GlobalVisTestNonRemovableFullHorizon (GlobalVisState *state)

TransactionId	GlobalVisTestNonRemovableHorizon (GlobalVisState *state)

bool	GlobalVisCheckRemovableXid (Relation rel, TransactionId xid)

bool	GlobalVisCheckRemovableFullXid (Relation rel, FullTransactionId fxid)

bool	XidInMVCCSnapshot (TransactionId xid, Snapshot snapshot)

struct HTAB *	HistoricSnapshotGetTupleCids (void)

void	SetupHistoricSnapshot (Snapshot historic_snapshot, struct HTAB *tuplecids)

void	TeardownHistoricSnapshot (bool is_error)

bool	HistoricSnapshotActive (void)

Size	EstimateSnapshotSpace (Snapshot snapshot)

void	SerializeSnapshot (Snapshot snapshot, char *start_address)

Snapshot	RestoreSnapshot (char *start_address)

void	RestoreTransactionSnapshot (Snapshot snapshot, void *source_pgproc)

Macro Definition Documentation

◆ EarlyPruningEnabled

#define EarlyPruningEnabled ( rel ) (old_snapshot_threshold >= 0 && RelationAllowsEarlyPruning(rel))

Definition at line 44 of file snapmgr.h.

◆ InitDirtySnapshot

#define InitDirtySnapshot ( snapshotdata ) ((snapshotdata).snapshot_type = SNAPSHOT_DIRTY)

Definition at line 74 of file snapmgr.h.

◆ InitNonVacuumableSnapshot

#define InitNonVacuumableSnapshot	(	snapshotdata,
		vistestp
	)

Value:

((snapshotdata).snapshot_type = SNAPSHOT_NON_VACUUMABLE, \

(snapshotdata).vistest = (vistestp))

SNAPSHOT_NON_VACUUMABLE

@ SNAPSHOT_NON_VACUUMABLE

Definition: snapshot.h:118

Definition at line 82 of file snapmgr.h.

◆ InitToastSnapshot

#define InitToastSnapshot	(	snapshotdata,
		l,
		w
	)

Value:

    ((snapshotdata).snapshot_type = SNAPSHOT_TOAST, \
     (snapshotdata).lsn = (l),                  \
     (snapshotdata).whenTaken = (w))

Definition at line 90 of file snapmgr.h.

◆ IsMVCCSnapshot

#define IsMVCCSnapshot ( snapshot )

Value:

((snapshot)->snapshot_type == SNAPSHOT_MVCC || \

(snapshot)->snapshot_type == SNAPSHOT_HISTORIC_MVCC)

SNAPSHOT_MVCC

@ SNAPSHOT_MVCC

Definition: snapshot.h:50

SNAPSHOT_HISTORIC_MVCC

@ SNAPSHOT_HISTORIC_MVCC

Definition: snapshot.h:109

Definition at line 96 of file snapmgr.h.

◆ OLD_SNAPSHOT_PADDING_ENTRIES

#define OLD_SNAPSHOT_PADDING_ENTRIES 10

Definition at line 31 of file snapmgr.h.

◆ OLD_SNAPSHOT_TIME_MAP_ENTRIES

#define OLD_SNAPSHOT_TIME_MAP_ENTRIES (old_snapshot_threshold + OLD_SNAPSHOT_PADDING_ENTRIES)

Definition at line 32 of file snapmgr.h.

◆ RelationAllowsEarlyPruning

#define RelationAllowsEarlyPruning ( rel )

Value:

( \
     RelationIsPermanent(rel) && !IsCatalogRelation(rel) \
  && !RelationIsAccessibleInLogicalDecoding(rel) \
)

Definition at line 38 of file snapmgr.h.

◆ SnapshotAny

#define SnapshotAny (&SnapshotAnyData)

Definition at line 67 of file snapmgr.h.

◆ SnapshotSelf

#define SnapshotSelf (&SnapshotSelfData)

Definition at line 66 of file snapmgr.h.

Typedef Documentation

◆ GlobalVisState

typedef struct GlobalVisState GlobalVisState

Definition at line 149 of file snapmgr.h.

Function Documentation

◆ ActiveSnapshotSet()

bool ActiveSnapshotSet ( void )

Definition at line 817 of file snapmgr.c.

 {
     return ActiveSnapshot != NULL;
 }

References ActiveSnapshot.

Referenced by _SPI_execute_plan(), BuildCachedPlan(), EnsurePortalSnapshotExists(), find_inheritance_children_extended(), ForgetPortalSnapshots(), index_concurrently_build(), pg_plan_query(), PortalRunUtility(), postquel_start(), RelationBuildPartitionDesc(), RelationGetPartitionDesc(), RevalidateCachedQuery(), and vacuum().

◆ AtEOXact_Snapshot()

void AtEOXact_Snapshot	(	bool	isCommit,
		bool	resetXmin
	)

Definition at line 1025 of file snapmgr.c.

 {
     /*
      * In transaction-snapshot mode we must release our privately-managed
      * reference to the transaction snapshot.  We must remove it from
      * RegisteredSnapshots to keep the check below happy.  But we don't bother
      * to do FreeSnapshot, for two reasons: the memory will go away with
      * TopTransactionContext anyway, and if someone has left the snapshot
      * stacked as active, we don't want the code below to be chasing through a
      * dangling pointer.
      */
     if (FirstXactSnapshot != NULL)
     {
         Assert(FirstXactSnapshot->regd_count > 0);
         Assert(!pairingheap_is_empty(&RegisteredSnapshots));
         pairingheap_remove(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
     }
     FirstXactSnapshot = NULL;
  
     /*
      * If we exported any snapshots, clean them up.
      */
     if (exportedSnapshots != NIL)
     {
         ListCell   *lc;
  
         /*
          * Get rid of the files.  Unlink failure is only a WARNING because (1)
          * it's too late to abort the transaction, and (2) leaving a leaked
          * file around has little real consequence anyway.
          *
          * We also need to remove the snapshots from RegisteredSnapshots to
          * prevent a warning below.
          *
          * As with the FirstXactSnapshot, we don't need to free resources of
          * the snapshot itself as it will go away with the memory context.
          */
         foreach(lc, exportedSnapshots)
         {
             ExportedSnapshot *esnap = (ExportedSnapshot *) lfirst(lc);
  
             if (unlink(esnap->snapfile))
                 elog(WARNING, "could not unlink file \"%s\": %m",
                      esnap->snapfile);
  
             pairingheap_remove(&RegisteredSnapshots,
                                &esnap->snapshot->ph_node);
         }
  
         exportedSnapshots = NIL;
     }
  
     /* Drop catalog snapshot if any */
     InvalidateCatalogSnapshot();
  
     /* On commit, complain about leftover snapshots */
     if (isCommit)
     {
         ActiveSnapshotElt *active;
  
         if (!pairingheap_is_empty(&RegisteredSnapshots))
             elog(WARNING, "registered snapshots seem to remain after cleanup");
  
         /* complain about unpopped active snapshots */
         for (active = ActiveSnapshot; active != NULL; active = active->as_next)
             elog(WARNING, "snapshot %p still active", active);
     }
  
     /*
      * And reset our state.  We don't need to free the memory explicitly --
      * it'll go away with TopTransactionContext.
      */
     ActiveSnapshot = NULL;
     OldestActiveSnapshot = NULL;
     pairingheap_reset(&RegisteredSnapshots);
  
     CurrentSnapshot = NULL;
     SecondarySnapshot = NULL;
  
     FirstSnapshotSet = false;
  
     /*
      * During normal commit processing, we call ProcArrayEndTransaction() to
      * reset the MyProc->xmin. That call happens prior to the call to
      * AtEOXact_Snapshot(), so we need not touch xmin here at all.
      */
     if (resetXmin)
         SnapshotResetXmin();
  
     Assert(resetXmin || MyProc->xmin == 0);
 }

References ActiveSnapshot, ActiveSnapshotElt::as_next, Assert(), CurrentSnapshot, elog(), exportedSnapshots, FirstSnapshotSet, FirstXactSnapshot, InvalidateCatalogSnapshot(), lfirst, MyProc, NIL, OldestActiveSnapshot, pairingheap_is_empty, pairingheap_remove(), pairingheap_reset, SnapshotData::ph_node, SnapshotData::regd_count, RegisteredSnapshots, SecondarySnapshot, ExportedSnapshot::snapfile, ExportedSnapshot::snapshot, SnapshotResetXmin(), WARNING, and PGPROC::xmin.

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

◆ AtSubAbort_Snapshot()

void AtSubAbort_Snapshot ( int level )

Definition at line 989 of file snapmgr.c.

 {
     /* Forget the active snapshots set by this subtransaction */
     while (ActiveSnapshot && ActiveSnapshot->as_level >= level)
     {
         ActiveSnapshotElt *next;
  
         next = ActiveSnapshot->as_next;
  
         /*
          * Decrement the snapshot's active count.  If it's still registered or
          * marked as active by an outer subtransaction, we can't free it yet.
          */
         Assert(ActiveSnapshot->as_snap->active_count >= 1);
         ActiveSnapshot->as_snap->active_count -= 1;
  
         if (ActiveSnapshot->as_snap->active_count == 0 &&
             ActiveSnapshot->as_snap->regd_count == 0)
             FreeSnapshot(ActiveSnapshot->as_snap);
  
         /* and free the stack element */
         pfree(ActiveSnapshot);
  
         ActiveSnapshot = next;
         if (ActiveSnapshot == NULL)
             OldestActiveSnapshot = NULL;
     }
  
     SnapshotResetXmin();
 }

References SnapshotData::active_count, ActiveSnapshot, ActiveSnapshotElt::as_level, ActiveSnapshotElt::as_next, ActiveSnapshotElt::as_snap, Assert(), FreeSnapshot(), next, OldestActiveSnapshot, pfree(), SnapshotData::regd_count, and SnapshotResetXmin().

Referenced by AbortSubTransaction().

◆ AtSubCommit_Snapshot()

void AtSubCommit_Snapshot ( int level )

Definition at line 968 of file snapmgr.c.

 {
     ActiveSnapshotElt *active;
  
     /*
      * Relabel the active snapshots set in this subtransaction as though they
      * are owned by the parent subxact.
      */
     for (active = ActiveSnapshot; active != NULL; active = active->as_next)
     {
         if (active->as_level < level)
             break;
         active->as_level = level - 1;
     }
 }

References ActiveSnapshot, ActiveSnapshotElt::as_level, and ActiveSnapshotElt::as_next.

Referenced by CommitSubTransaction().

◆ DeleteAllExportedSnapshotFiles()

void DeleteAllExportedSnapshotFiles ( void )

Definition at line 1584 of file snapmgr.c.

 {
     char        buf[MAXPGPATH + sizeof(SNAPSHOT_EXPORT_DIR)];
     DIR        *s_dir;
     struct dirent *s_de;
  
     /*
      * Problems in reading the directory, or unlinking files, are reported at
      * LOG level.  Since we're running in the startup process, ERROR level
      * would prevent database start, and it's not important enough for that.
      */
     s_dir = AllocateDir(SNAPSHOT_EXPORT_DIR);
  
     while ((s_de = ReadDirExtended(s_dir, SNAPSHOT_EXPORT_DIR, LOG)) != NULL)
     {
         if (strcmp(s_de->d_name, ".") == 0 ||
             strcmp(s_de->d_name, "..") == 0)
             continue;
  
         snprintf(buf, sizeof(buf), SNAPSHOT_EXPORT_DIR "/%s", s_de->d_name);
  
         if (unlink(buf) != 0)
             ereport(LOG,
                     (errcode_for_file_access(),
                      errmsg("could not remove file \"%s\": %m", buf)));
     }
  
     FreeDir(s_dir);
 }

References AllocateDir(), buf, dirent::d_name, ereport, errcode_for_file_access(), errmsg(), FreeDir(), LOG, MAXPGPATH, ReadDirExtended(), SNAPSHOT_EXPORT_DIR, and snprintf.

Referenced by StartupXLOG().

◆ EstimateSnapshotSpace()

Size EstimateSnapshotSpace ( Snapshot snapshot )

Definition at line 2123 of file snapmgr.c.

 {
     Size        size;
  
     Assert(snapshot != InvalidSnapshot);
     Assert(snapshot->snapshot_type == SNAPSHOT_MVCC);
  
     /* We allocate any XID arrays needed in the same palloc block. */
     size = add_size(sizeof(SerializedSnapshotData),
                     mul_size(snapshot->xcnt, sizeof(TransactionId)));
     if (snapshot->subxcnt > 0 &&
         (!snapshot->suboverflowed || snapshot->takenDuringRecovery))
         size = add_size(size,
                         mul_size(snapshot->subxcnt, sizeof(TransactionId)));
  
     return size;
 }

References add_size(), Assert(), InvalidSnapshot, mul_size(), SNAPSHOT_MVCC, SnapshotData::snapshot_type, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::takenDuringRecovery, and SnapshotData::xcnt.

Referenced by ExecBitmapHeapEstimate(), index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeParallelDSM(), and table_parallelscan_estimate().

◆ ExportSnapshot()

char* ExportSnapshot ( Snapshot snapshot )

Definition at line 1125 of file snapmgr.c.

 {
     TransactionId topXid;
     TransactionId *children;
     ExportedSnapshot *esnap;
     int         nchildren;
     int         addTopXid;
     StringInfoData buf;
     FILE       *f;
     int         i;
     MemoryContext oldcxt;
     char        path[MAXPGPATH];
     char        pathtmp[MAXPGPATH];
  
     /*
      * It's tempting to call RequireTransactionBlock here, since it's not very
      * useful to export a snapshot that will disappear immediately afterwards.
      * However, we haven't got enough information to do that, since we don't
      * know if we're at top level or not.  For example, we could be inside a
      * plpgsql function that is going to fire off other transactions via
      * dblink.  Rather than disallow perfectly legitimate usages, don't make a
      * check.
      *
      * Also note that we don't make any restriction on the transaction's
      * isolation level; however, importers must check the level if they are
      * serializable.
      */
  
     /*
      * Get our transaction ID if there is one, to include in the snapshot.
      */
     topXid = GetTopTransactionIdIfAny();
  
     /*
      * We cannot export a snapshot from a subtransaction because there's no
      * easy way for importers to verify that the same subtransaction is still
      * running.
      */
     if (IsSubTransaction())
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
                  errmsg("cannot export a snapshot from a subtransaction")));
  
     /*
      * We do however allow previous committed subtransactions to exist.
      * Importers of the snapshot must see them as still running, so get their
      * XIDs to add them to the snapshot.
      */
     nchildren = xactGetCommittedChildren(&children);
  
     /*
      * Generate file path for the snapshot.  We start numbering of snapshots
      * inside the transaction from 1.
      */
     snprintf(path, sizeof(path), SNAPSHOT_EXPORT_DIR "/%08X-%08X-%d",
              MyProc->backendId, MyProc->lxid, list_length(exportedSnapshots) + 1);
  
     /*
      * Copy the snapshot into TopTransactionContext, add it to the
      * exportedSnapshots list, and mark it pseudo-registered.  We do this to
      * ensure that the snapshot's xmin is honored for the rest of the
      * transaction.
      */
     snapshot = CopySnapshot(snapshot);
  
     oldcxt = MemoryContextSwitchTo(TopTransactionContext);
     esnap = (ExportedSnapshot *) palloc(sizeof(ExportedSnapshot));
     esnap->snapfile = pstrdup(path);
     esnap->snapshot = snapshot;
     exportedSnapshots = lappend(exportedSnapshots, esnap);
     MemoryContextSwitchTo(oldcxt);
  
     snapshot->regd_count++;
     pairingheap_add(&RegisteredSnapshots, &snapshot->ph_node);
  
     /*
      * Fill buf with a text serialization of the snapshot, plus identification
      * data about this transaction.  The format expected by ImportSnapshot is
      * pretty rigid: each line must be fieldname:value.
      */
     initStringInfo(&buf);
  
     appendStringInfo(&buf, "vxid:%d/%u\n", MyProc->backendId, MyProc->lxid);
     appendStringInfo(&buf, "pid:%d\n", MyProcPid);
     appendStringInfo(&buf, "dbid:%u\n", MyDatabaseId);
     appendStringInfo(&buf, "iso:%d\n", XactIsoLevel);
     appendStringInfo(&buf, "ro:%d\n", XactReadOnly);
  
     appendStringInfo(&buf, "xmin:%u\n", snapshot->xmin);
     appendStringInfo(&buf, "xmax:%u\n", snapshot->xmax);
  
     /*
      * We must include our own top transaction ID in the top-xid data, since
      * by definition we will still be running when the importing transaction
      * adopts the snapshot, but GetSnapshotData never includes our own XID in
      * the snapshot.  (There must, therefore, be enough room to add it.)
      *
      * However, it could be that our topXid is after the xmax, in which case
      * we shouldn't include it because xip[] members are expected to be before
      * xmax.  (We need not make the same check for subxip[] members, see
      * snapshot.h.)
      */
     addTopXid = (TransactionIdIsValid(topXid) &&
                  TransactionIdPrecedes(topXid, snapshot->xmax)) ? 1 : 0;
     appendStringInfo(&buf, "xcnt:%d\n", snapshot->xcnt + addTopXid);
     for (i = 0; i < snapshot->xcnt; i++)
         appendStringInfo(&buf, "xip:%u\n", snapshot->xip[i]);
     if (addTopXid)
         appendStringInfo(&buf, "xip:%u\n", topXid);
  
     /*
      * Similarly, we add our subcommitted child XIDs to the subxid data. Here,
      * we have to cope with possible overflow.
      */
     if (snapshot->suboverflowed ||
         snapshot->subxcnt + nchildren > GetMaxSnapshotSubxidCount())
         appendStringInfoString(&buf, "sof:1\n");
     else
     {
         appendStringInfoString(&buf, "sof:0\n");
         appendStringInfo(&buf, "sxcnt:%d\n", snapshot->subxcnt + nchildren);
         for (i = 0; i < snapshot->subxcnt; i++)
             appendStringInfo(&buf, "sxp:%u\n", snapshot->subxip[i]);
         for (i = 0; i < nchildren; i++)
             appendStringInfo(&buf, "sxp:%u\n", children[i]);
     }
     appendStringInfo(&buf, "rec:%u\n", snapshot->takenDuringRecovery);
  
     /*
      * Now write the text representation into a file.  We first write to a
      * ".tmp" filename, and rename to final filename if no error.  This
      * ensures that no other backend can read an incomplete file
      * (ImportSnapshot won't allow it because of its valid-characters check).
      */
     snprintf(pathtmp, sizeof(pathtmp), "%s.tmp", path);
     if (!(f = AllocateFile(pathtmp, PG_BINARY_W)))
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not create file \"%s\": %m", pathtmp)));
  
     if (fwrite(buf.data, buf.len, 1, f) != 1)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m", pathtmp)));
  
     /* no fsync() since file need not survive a system crash */
  
     if (FreeFile(f))
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m", pathtmp)));
  
     /*
      * Now that we have written everything into a .tmp file, rename the file
      * to remove the .tmp suffix.
      */
     if (rename(pathtmp, path) < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not rename file \"%s\" to \"%s\": %m",
                         pathtmp, path)));
  
     /*
      * The basename of the file is what we return from pg_export_snapshot().
      * It's already in path in a textual format and we know that the path
      * starts with SNAPSHOT_EXPORT_DIR.  Skip over the prefix and the slash
      * and pstrdup it so as not to return the address of a local variable.
      */
     return pstrdup(path + strlen(SNAPSHOT_EXPORT_DIR) + 1);
 }

References AllocateFile(), appendStringInfo(), appendStringInfoString(), PGPROC::backendId, buf, CopySnapshot(), ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, exportedSnapshots, FreeFile(), GetMaxSnapshotSubxidCount(), GetTopTransactionIdIfAny(), i, initStringInfo(), IsSubTransaction(), lappend(), list_length(), PGPROC::lxid, MAXPGPATH, MemoryContextSwitchTo(), MyDatabaseId, MyProc, MyProcPid, pairingheap_add(), palloc(), PG_BINARY_W, SnapshotData::ph_node, pstrdup(), SnapshotData::regd_count, RegisteredSnapshots, ExportedSnapshot::snapfile, ExportedSnapshot::snapshot, SNAPSHOT_EXPORT_DIR, snprintf, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TopTransactionContext, TransactionIdIsValid, TransactionIdPrecedes(), xactGetCommittedChildren(), XactIsoLevel, XactReadOnly, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by pg_export_snapshot(), and SnapBuildExportSnapshot().

◆ GetActiveSnapshot()

Snapshot GetActiveSnapshot ( void )

Definition at line 805 of file snapmgr.c.

 {
     Assert(ActiveSnapshot != NULL);
  
     return ActiveSnapshot->as_snap;
 }

References ActiveSnapshot, ActiveSnapshotElt::as_snap, and Assert().

Referenced by _SPI_execute_plan(), ATExecDetachPartitionFinalize(), BeginCopyTo(), DoCopyTo(), EnsurePortalSnapshotExists(), ExecCreateTableAs(), ExecParallelGetQueryDesc(), execute_sql_string(), ExecuteQuery(), ExplainOnePlan(), find_inheritance_children_extended(), InitializeParallelDSM(), inv_open(), PerformCursorOpen(), pg_current_snapshot(), pg_export_snapshot(), pgrowlocks(), PortalRunUtility(), PortalStart(), postquel_start(), ProcessQuery(), refresh_matview_datafill(), RelationGetPartitionDesc(), spgvacuumscan(), and SPI_cursor_open_internal().

◆ GetCatalogSnapshot()

Snapshot GetCatalogSnapshot ( Oid relid )

Definition at line 387 of file snapmgr.c.

 {
     /*
      * Return historic snapshot while we're doing logical decoding, so we can
      * see the appropriate state of the catalog.
      *
      * This is the primary reason for needing to reset the system caches after
      * finishing decoding.
      */
     if (HistoricSnapshotActive())
         return HistoricSnapshot;
  
     return GetNonHistoricCatalogSnapshot(relid);
 }

References GetNonHistoricCatalogSnapshot(), HistoricSnapshot, and HistoricSnapshotActive().

Referenced by process_settings(), systable_beginscan(), systable_beginscan_ordered(), systable_recheck_tuple(), and table_beginscan_catalog().

◆ GetLatestSnapshot()

Snapshot GetLatestSnapshot ( void )

Definition at line 326 of file snapmgr.c.

 {
     /*
      * We might be able to relax this, but nothing that could otherwise work
      * needs it.
      */
     if (IsInParallelMode())
         elog(ERROR,
              "cannot update SecondarySnapshot during a parallel operation");
  
     /*
      * So far there are no cases requiring support for GetLatestSnapshot()
      * during logical decoding, but it wouldn't be hard to add if required.
      */
     Assert(!HistoricSnapshotActive());
  
     /* If first call in transaction, go ahead and set the xact snapshot */
     if (!FirstSnapshotSet)
         return GetTransactionSnapshot();
  
     SecondarySnapshot = GetSnapshotData(&SecondarySnapshotData);
  
     return SecondarySnapshot;
 }

References Assert(), elog(), ERROR, FirstSnapshotSet, GetSnapshotData(), GetTransactionSnapshot(), HistoricSnapshotActive(), IsInParallelMode(), SecondarySnapshot, and SecondarySnapshotData.

Referenced by AlterDomainNotNull(), asyncQueueReadAllNotifications(), ATRewriteTable(), check_default_partition_contents(), currtid_internal(), IndexCheckExclusion(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PerformCheck(), ScanSourceDatabasePgClass(), validateDomainConstraint(), and validateForeignKeyConstraint().

◆ GetNonHistoricCatalogSnapshot()

Snapshot GetNonHistoricCatalogSnapshot ( Oid relid )

Definition at line 409 of file snapmgr.c.

 {
     /*
      * If the caller is trying to scan a relation that has no syscache, no
      * catcache invalidations will be sent when it is updated.  For a few key
      * relations, snapshot invalidations are sent instead.  If we're trying to
      * scan a relation for which neither catcache nor snapshot invalidations
      * are sent, we must refresh the snapshot every time.
      */
     if (CatalogSnapshot &&
         !RelationInvalidatesSnapshotsOnly(relid) &&
         !RelationHasSysCache(relid))
         InvalidateCatalogSnapshot();
  
     if (CatalogSnapshot == NULL)
     {
         /* Get new snapshot. */
         CatalogSnapshot = GetSnapshotData(&CatalogSnapshotData);
  
         /*
          * Make sure the catalog snapshot will be accounted for in decisions
          * about advancing PGPROC->xmin.  We could apply RegisterSnapshot, but
          * that would result in making a physical copy, which is overkill; and
          * it would also create a dependency on some resource owner, which we
          * do not want for reasons explained at the head of this file. Instead
          * just shove the CatalogSnapshot into the pairing heap manually. This
          * has to be reversed in InvalidateCatalogSnapshot, of course.
          *
          * NB: it had better be impossible for this to throw error, since the
          * CatalogSnapshot pointer is already valid.
          */
         pairingheap_add(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
     }
  
     return CatalogSnapshot;
 }

References CatalogSnapshot, CatalogSnapshotData, GetSnapshotData(), InvalidateCatalogSnapshot(), pairingheap_add(), SnapshotData::ph_node, RegisteredSnapshots, RelationHasSysCache(), and RelationInvalidatesSnapshotsOnly().

Referenced by GetCatalogSnapshot(), and ScanPgRelation().

◆ GetOldestSnapshot()

Snapshot GetOldestSnapshot ( void )

Definition at line 358 of file snapmgr.c.

 {
     Snapshot    OldestRegisteredSnapshot = NULL;
     XLogRecPtr  RegisteredLSN = InvalidXLogRecPtr;
  
     if (!pairingheap_is_empty(&RegisteredSnapshots))
     {
         OldestRegisteredSnapshot = pairingheap_container(SnapshotData, ph_node,
                                                          pairingheap_first(&RegisteredSnapshots));
         RegisteredLSN = OldestRegisteredSnapshot->lsn;
     }
  
     if (OldestActiveSnapshot != NULL)
     {
         XLogRecPtr  ActiveLSN = OldestActiveSnapshot->as_snap->lsn;
  
         if (XLogRecPtrIsInvalid(RegisteredLSN) || RegisteredLSN > ActiveLSN)
             return OldestActiveSnapshot->as_snap;
     }
  
     return OldestRegisteredSnapshot;
 }

References ActiveSnapshotElt::as_snap, InvalidXLogRecPtr, SnapshotData::lsn, OldestActiveSnapshot, pairingheap_container, pairingheap_first(), pairingheap_is_empty, RegisteredSnapshots, and XLogRecPtrIsInvalid.

Referenced by init_toast_snapshot().

◆ GetOldSnapshotThresholdTimestamp()

TimestampTz GetOldSnapshotThresholdTimestamp ( void )

Definition at line 1705 of file snapmgr.c.

 {
     TimestampTz threshold_timestamp;
  
     SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
     threshold_timestamp = oldSnapshotControl->threshold_timestamp;
     SpinLockRelease(&oldSnapshotControl->mutex_threshold);
  
     return threshold_timestamp;
 }

References OldSnapshotControlData::mutex_threshold, oldSnapshotControl, SpinLockAcquire, SpinLockRelease, and OldSnapshotControlData::threshold_timestamp.

Referenced by TestForOldSnapshot_impl().

◆ GetSnapshotCurrentTimestamp()

TimestampTz GetSnapshotCurrentTimestamp ( void )

Definition at line 1680 of file snapmgr.c.

 {
     TimestampTz now = GetCurrentTimestamp();
  
     /*
      * Don't let time move backward; if it hasn't advanced, use the old value.
      */
     SpinLockAcquire(&oldSnapshotControl->mutex_current);
     if (now <= oldSnapshotControl->current_timestamp)
         now = oldSnapshotControl->current_timestamp;
     else
         oldSnapshotControl->current_timestamp = now;
     SpinLockRelease(&oldSnapshotControl->mutex_current);
  
     return now;
 }

References current_timestamp(), OldSnapshotControlData::current_timestamp, GetCurrentTimestamp(), OldSnapshotControlData::mutex_current, now(), oldSnapshotControl, SpinLockAcquire, and SpinLockRelease.

Referenced by GetSnapshotDataInitOldSnapshot(), SnapshotTooOldMagicForTest(), and TransactionIdLimitedForOldSnapshots().

◆ GetTransactionSnapshot()

Snapshot GetTransactionSnapshot ( void )

Definition at line 251 of file snapmgr.c.

 {
     /*
      * Return historic snapshot if doing logical decoding. We'll never need a
      * non-historic transaction snapshot in this (sub-)transaction, so there's
      * no need to be careful to set one up for later calls to
      * GetTransactionSnapshot().
      */
     if (HistoricSnapshotActive())
     {
         Assert(!FirstSnapshotSet);
         return HistoricSnapshot;
     }
  
     /* First call in transaction? */
     if (!FirstSnapshotSet)
     {
         /*
          * Don't allow catalog snapshot to be older than xact snapshot.  Must
          * do this first to allow the empty-heap Assert to succeed.
          */
         InvalidateCatalogSnapshot();
  
         Assert(pairingheap_is_empty(&RegisteredSnapshots));
         Assert(FirstXactSnapshot == NULL);
  
         if (IsInParallelMode())
             elog(ERROR,
                  "cannot take query snapshot during a parallel operation");
  
         /*
          * In transaction-snapshot mode, the first snapshot must live until
          * end of xact regardless of what the caller does with it, so we must
          * make a copy of it rather than returning CurrentSnapshotData
          * directly.  Furthermore, if we're running in serializable mode,
          * predicate.c needs to wrap the snapshot fetch in its own processing.
          */
         if (IsolationUsesXactSnapshot())
         {
             /* First, create the snapshot in CurrentSnapshotData */
             if (IsolationIsSerializable())
                 CurrentSnapshot = GetSerializableTransactionSnapshot(&CurrentSnapshotData);
             else
                 CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
             /* Make a saved copy */
             CurrentSnapshot = CopySnapshot(CurrentSnapshot);
             FirstXactSnapshot = CurrentSnapshot;
             /* Mark it as "registered" in FirstXactSnapshot */
             FirstXactSnapshot->regd_count++;
             pairingheap_add(&RegisteredSnapshots, &FirstXactSnapshot->ph_node);
         }
         else
             CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
  
         FirstSnapshotSet = true;
         return CurrentSnapshot;
     }
  
     if (IsolationUsesXactSnapshot())
         return CurrentSnapshot;
  
     /* Don't allow catalog snapshot to be older than xact snapshot. */
     InvalidateCatalogSnapshot();
  
     CurrentSnapshot = GetSnapshotData(&CurrentSnapshotData);
  
     return CurrentSnapshot;
 }

References Assert(), CopySnapshot(), CurrentSnapshot, CurrentSnapshotData, elog(), ERROR, FirstSnapshotSet, FirstXactSnapshot, GetSerializableTransactionSnapshot(), GetSnapshotData(), HistoricSnapshot, HistoricSnapshotActive(), InvalidateCatalogSnapshot(), IsInParallelMode(), IsolationIsSerializable, IsolationUsesXactSnapshot, pairingheap_add(), pairingheap_is_empty, SnapshotData::ph_node, SnapshotData::regd_count, and RegisteredSnapshots.

Referenced by _bt_begin_parallel(), _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), begin_replication_step(), bt_check_every_level(), BuildCachedPlan(), CheckTargetForConflictsIn(), cluster_multiple_rels(), DefineIndex(), EnsurePortalSnapshotExists(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), ExecuteCallStmt(), fmgr_sql(), get_database_list(), get_subscription_list(), GetLatestSnapshot(), HandleFunctionRequest(), heapam_index_build_range_scan(), initialize_worker_spi(), InitializeParallelDSM(), InitPostgres(), LogicalRepSyncTableStart(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), PortalStart(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ri_PerformCheck(), SPI_cursor_open_internal(), vacuum(), vacuum_rel(), verify_heapam(), and XidIsConcurrent().

◆ GlobalVisCheckRemovableFullXid()

bool GlobalVisCheckRemovableFullXid	(	Relation	rel,
		FullTransactionId	fxid
	)

Definition at line 4300 of file procarray.c.

 {
     GlobalVisState *state;
  
     state = GlobalVisTestFor(rel);
  
     return GlobalVisTestIsRemovableFullXid(state, fxid);
 }

References GlobalVisTestFor(), and GlobalVisTestIsRemovableFullXid().

Referenced by _bt_pendingfsm_finalize(), BTPageIsRecyclable(), and gistPageRecyclable().

◆ GlobalVisCheckRemovableXid()

bool GlobalVisCheckRemovableXid	(	Relation	rel,
		TransactionId	xid
	)

Definition at line 4314 of file procarray.c.

 {
     GlobalVisState *state;
  
     state = GlobalVisTestFor(rel);
  
     return GlobalVisTestIsRemovableXid(state, xid);
 }

References GlobalVisTestFor(), and GlobalVisTestIsRemovableXid().

Referenced by GinPageIsRecyclable().

◆ GlobalVisTestFor()

GlobalVisState* GlobalVisTestFor ( Relation rel )

Definition at line 4091 of file procarray.c.

 {
     GlobalVisState *state = NULL;
  
     /* XXX: we should assert that a snapshot is pushed or registered */
     Assert(RecentXmin);
  
     switch (GlobalVisHorizonKindForRel(rel))
     {
         case VISHORIZON_SHARED:
             state = &GlobalVisSharedRels;
             break;
         case VISHORIZON_CATALOG:
             state = &GlobalVisCatalogRels;
             break;
         case VISHORIZON_DATA:
             state = &GlobalVisDataRels;
             break;
         case VISHORIZON_TEMP:
             state = &GlobalVisTempRels;
             break;
     }
  
     Assert(FullTransactionIdIsValid(state->definitely_needed) &&
            FullTransactionIdIsValid(state->maybe_needed));
  
     return state;
 }

References Assert(), FullTransactionIdIsValid, GlobalVisCatalogRels, GlobalVisDataRels, GlobalVisHorizonKindForRel(), GlobalVisSharedRels, GlobalVisTempRels, RecentXmin, VISHORIZON_CATALOG, VISHORIZON_DATA, VISHORIZON_SHARED, and VISHORIZON_TEMP.

Referenced by get_actual_variable_endpoint(), GlobalVisCheckRemovableFullXid(), GlobalVisCheckRemovableXid(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_page_prune_opt(), heap_vacuum_rel(), and vacuumRedirectAndPlaceholder().

◆ GlobalVisTestIsRemovableFullXid()

bool GlobalVisTestIsRemovableFullXid	(	GlobalVisState *	state,
		FullTransactionId	fxid
	)

Definition at line 4206 of file procarray.c.

 {
     /*
      * If fxid is older than maybe_needed bound, it definitely is visible to
      * everyone.
      */
     if (FullTransactionIdPrecedes(fxid, state->maybe_needed))
         return true;
  
     /*
      * If fxid is >= definitely_needed bound, it is very likely to still be
      * considered running.
      */
     if (FullTransactionIdFollowsOrEquals(fxid, state->definitely_needed))
         return false;
  
     /*
      * fxid is between maybe_needed and definitely_needed, i.e. there might or
      * might not exist a snapshot considering fxid running. If it makes sense,
      * update boundaries and recheck.
      */
     if (GlobalVisTestShouldUpdate(state))
     {
         GlobalVisUpdate();
  
         Assert(FullTransactionIdPrecedes(fxid, state->definitely_needed));
  
         return FullTransactionIdPrecedes(fxid, state->maybe_needed);
     }
     else
         return false;
 }

References Assert(), FullTransactionIdFollowsOrEquals, FullTransactionIdPrecedes, GlobalVisTestShouldUpdate(), and GlobalVisUpdate().

Referenced by GlobalVisCheckRemovableFullXid(), and GlobalVisTestIsRemovableXid().

◆ GlobalVisTestIsRemovableXid()

bool GlobalVisTestIsRemovableXid	(	GlobalVisState *	state,
		TransactionId	xid
	)

Definition at line 4248 of file procarray.c.

 {
     FullTransactionId fxid;
  
     /*
      * Convert 32 bit argument to FullTransactionId. We can do so safely
      * because we know the xid has to, at the very least, be between
      * [oldestXid, nextXid), i.e. within 2 billion of xid. To avoid taking a
      * lock to determine either, we can just compare with
      * state->definitely_needed, which was based on those value at the time
      * the current snapshot was built.
      */
     fxid = FullXidRelativeTo(state->definitely_needed, xid);
  
     return GlobalVisTestIsRemovableFullXid(state, fxid);
 }

References FullXidRelativeTo(), and GlobalVisTestIsRemovableFullXid().

Referenced by GlobalVisCheckRemovableXid(), heap_page_prune_opt(), heap_prune_satisfies_vacuum(), HeapTupleIsSurelyDead(), HeapTupleSatisfiesNonVacuumable(), and vacuumRedirectAndPlaceholder().

◆ GlobalVisTestNonRemovableFullHorizon()

FullTransactionId GlobalVisTestNonRemovableFullHorizon ( GlobalVisState * state )

Definition at line 4275 of file procarray.c.

 {
     /* acquire accurate horizon if not already done */
     if (GlobalVisTestShouldUpdate(state))
         GlobalVisUpdate();
  
     return state->maybe_needed;
 }

References GlobalVisTestShouldUpdate(), and GlobalVisUpdate().

Referenced by GlobalVisTestNonRemovableHorizon().

◆ GlobalVisTestNonRemovableHorizon()

TransactionId GlobalVisTestNonRemovableHorizon ( GlobalVisState * state )

Definition at line 4286 of file procarray.c.

 {
     FullTransactionId cutoff;
  
     cutoff = GlobalVisTestNonRemovableFullHorizon(state);
  
     return XidFromFullTransactionId(cutoff);
 }

References GlobalVisTestNonRemovableFullHorizon(), and XidFromFullTransactionId.

Referenced by heap_page_prune_opt(), and heap_prune_satisfies_vacuum().

◆ HaveRegisteredOrActiveSnapshot()

bool HaveRegisteredOrActiveSnapshot ( void )

Definition at line 1641 of file snapmgr.c.

 {
     if (ActiveSnapshot != NULL)
         return true;
  
     /*
      * The catalog snapshot is in RegisteredSnapshots when valid, but can be
      * removed at any time due to invalidation processing. If explicitly
      * registered more than one snapshot has to be in RegisteredSnapshots.
      */
     if (CatalogSnapshot != NULL &&
         pairingheap_is_singular(&RegisteredSnapshots))
         return false;
  
     return !pairingheap_is_empty(&RegisteredSnapshots);
 }

References ActiveSnapshot, CatalogSnapshot, pairingheap_is_empty, pairingheap_is_singular, and RegisteredSnapshots.

Referenced by init_toast_snapshot(), and SnapBuildInitialSnapshot().

◆ HistoricSnapshotActive()

bool HistoricSnapshotActive ( void )

Definition at line 2103 of file snapmgr.c.

 {
     return HistoricSnapshot != NULL;
 }

References HistoricSnapshot.

Referenced by GetCatalogSnapshot(), GetLatestSnapshot(), GetTransactionSnapshot(), HistoricSnapshotGetTupleCids(), RelationClearRelation(), RelationGetIdentityKeyBitmap(), RelationInitPhysicalAddr(), SetTransactionSnapshot(), and SnapBuildInitialSnapshot().

◆ HistoricSnapshotGetTupleCids()

struct HTAB* HistoricSnapshotGetTupleCids ( void )

Definition at line 2109 of file snapmgr.c.

 {
     Assert(HistoricSnapshotActive());
     return tuplecid_data;
 }

References Assert(), HistoricSnapshotActive(), and tuplecid_data.

Referenced by HeapTupleSatisfiesHistoricMVCC().

◆ ImportSnapshot()

void ImportSnapshot ( const char * idstr )

Definition at line 1396 of file snapmgr.c.

 {
     char        path[MAXPGPATH];
     FILE       *f;
     struct stat stat_buf;
     char       *filebuf;
     int         xcnt;
     int         i;
     VirtualTransactionId src_vxid;
     int         src_pid;
     Oid         src_dbid;
     int         src_isolevel;
     bool        src_readonly;
     SnapshotData snapshot;
  
     /*
      * Must be at top level of a fresh transaction.  Note in particular that
      * we check we haven't acquired an XID --- if we have, it's conceivable
      * that the snapshot would show it as not running, making for very screwy
      * behavior.
      */
     if (FirstSnapshotSet ||
         GetTopTransactionIdIfAny() != InvalidTransactionId ||
         IsSubTransaction())
         ereport(ERROR,
                 (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
                  errmsg("SET TRANSACTION SNAPSHOT must be called before any query")));
  
     /*
      * If we are in read committed mode then the next query would execute with
      * a new snapshot thus making this function call quite useless.
      */
     if (!IsolationUsesXactSnapshot())
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("a snapshot-importing transaction must have isolation level SERIALIZABLE or REPEATABLE READ")));
  
     /*
      * Verify the identifier: only 0-9, A-F and hyphens are allowed.  We do
      * this mainly to prevent reading arbitrary files.
      */
     if (strspn(idstr, "0123456789ABCDEF-") != strlen(idstr))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid snapshot identifier: \"%s\"", idstr)));
  
     /* OK, read the file */
     snprintf(path, MAXPGPATH, SNAPSHOT_EXPORT_DIR "/%s", idstr);
  
     f = AllocateFile(path, PG_BINARY_R);
     if (!f)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("invalid snapshot identifier: \"%s\"", idstr)));
  
     /* get the size of the file so that we know how much memory we need */
     if (fstat(fileno(f), &stat_buf))
         elog(ERROR, "could not stat file \"%s\": %m", path);
  
     /* and read the file into a palloc'd string */
     filebuf = (char *) palloc(stat_buf.st_size + 1);
     if (fread(filebuf, stat_buf.st_size, 1, f) != 1)
         elog(ERROR, "could not read file \"%s\": %m", path);
  
     filebuf[stat_buf.st_size] = '\0';
  
     FreeFile(f);
  
     /*
      * Construct a snapshot struct by parsing the file content.
      */
     memset(&snapshot, 0, sizeof(snapshot));
  
     parseVxidFromText("vxid:", &filebuf, path, &src_vxid);
     src_pid = parseIntFromText("pid:", &filebuf, path);
     /* we abuse parseXidFromText a bit here ... */
     src_dbid = parseXidFromText("dbid:", &filebuf, path);
     src_isolevel = parseIntFromText("iso:", &filebuf, path);
     src_readonly = parseIntFromText("ro:", &filebuf, path);
  
     snapshot.snapshot_type = SNAPSHOT_MVCC;
  
     snapshot.xmin = parseXidFromText("xmin:", &filebuf, path);
     snapshot.xmax = parseXidFromText("xmax:", &filebuf, path);
  
     snapshot.xcnt = xcnt = parseIntFromText("xcnt:", &filebuf, path);
  
     /* sanity-check the xid count before palloc */
     if (xcnt < 0 || xcnt > GetMaxSnapshotXidCount())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", path)));
  
     snapshot.xip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
     for (i = 0; i < xcnt; i++)
         snapshot.xip[i] = parseXidFromText("xip:", &filebuf, path);
  
     snapshot.suboverflowed = parseIntFromText("sof:", &filebuf, path);
  
     if (!snapshot.suboverflowed)
     {
         snapshot.subxcnt = xcnt = parseIntFromText("sxcnt:", &filebuf, path);
  
         /* sanity-check the xid count before palloc */
         if (xcnt < 0 || xcnt > GetMaxSnapshotSubxidCount())
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                      errmsg("invalid snapshot data in file \"%s\"", path)));
  
         snapshot.subxip = (TransactionId *) palloc(xcnt * sizeof(TransactionId));
         for (i = 0; i < xcnt; i++)
             snapshot.subxip[i] = parseXidFromText("sxp:", &filebuf, path);
     }
     else
     {
         snapshot.subxcnt = 0;
         snapshot.subxip = NULL;
     }
  
     snapshot.takenDuringRecovery = parseIntFromText("rec:", &filebuf, path);
  
     /*
      * Do some additional sanity checking, just to protect ourselves.  We
      * don't trouble to check the array elements, just the most critical
      * fields.
      */
     if (!VirtualTransactionIdIsValid(src_vxid) ||
         !OidIsValid(src_dbid) ||
         !TransactionIdIsNormal(snapshot.xmin) ||
         !TransactionIdIsNormal(snapshot.xmax))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("invalid snapshot data in file \"%s\"", path)));
  
     /*
      * If we're serializable, the source transaction must be too, otherwise
      * predicate.c has problems (SxactGlobalXmin could go backwards).  Also, a
      * non-read-only transaction can't adopt a snapshot from a read-only
      * transaction, as predicate.c handles the cases very differently.
      */
     if (IsolationIsSerializable())
     {
         if (src_isolevel != XACT_SERIALIZABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("a serializable transaction cannot import a snapshot from a non-serializable transaction")));
         if (src_readonly && !XactReadOnly)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("a non-read-only serializable transaction cannot import a snapshot from a read-only transaction")));
     }
  
     /*
      * We cannot import a snapshot that was taken in a different database,
      * because vacuum calculates OldestXmin on a per-database basis; so the
      * source transaction's xmin doesn't protect us from data loss.  This
      * restriction could be removed if the source transaction were to mark its
      * xmin as being globally applicable.  But that would require some
      * additional syntax, since that has to be known when the snapshot is
      * initially taken.  (See pgsql-hackers discussion of 2011-10-21.)
      */
     if (src_dbid != MyDatabaseId)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("cannot import a snapshot from a different database")));
  
     /* OK, install the snapshot */
     SetTransactionSnapshot(&snapshot, &src_vxid, src_pid, NULL);
 }

References AllocateFile(), elog(), ereport, errcode(), errmsg(), ERROR, FirstSnapshotSet, FreeFile(), fstat, GetMaxSnapshotSubxidCount(), GetMaxSnapshotXidCount(), GetTopTransactionIdIfAny(), i, InvalidTransactionId, IsolationIsSerializable, IsolationUsesXactSnapshot, IsSubTransaction(), MAXPGPATH, MyDatabaseId, OidIsValid, palloc(), parseIntFromText(), parseVxidFromText(), parseXidFromText(), PG_BINARY_R, SetTransactionSnapshot(), SNAPSHOT_EXPORT_DIR, SNAPSHOT_MVCC, SnapshotData::snapshot_type, snprintf, stat::st_size, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TransactionIdIsNormal, VirtualTransactionIdIsValid, XACT_SERIALIZABLE, XactReadOnly, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by ExecSetVariableStmt().

◆ InvalidateCatalogSnapshot()

void InvalidateCatalogSnapshot ( void )

Definition at line 457 of file snapmgr.c.

 {
     if (CatalogSnapshot)
     {
         pairingheap_remove(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
         CatalogSnapshot = NULL;
         SnapshotResetXmin();
     }
 }

References CatalogSnapshot, pairingheap_remove(), SnapshotData::ph_node, RegisteredSnapshots, and SnapshotResetXmin().

Referenced by AtEOXact_Snapshot(), CopyFrom(), GetNonHistoricCatalogSnapshot(), GetTransactionSnapshot(), InitPostgres(), InvalidateCatalogSnapshotConditionally(), InvalidateSystemCachesExtended(), LocalExecuteInvalidationMessage(), SetTransactionSnapshot(), SnapBuildInitialSnapshot(), and wait_for_relation_state_change().

◆ InvalidateCatalogSnapshotConditionally()

void InvalidateCatalogSnapshotConditionally ( void )

Definition at line 478 of file snapmgr.c.

 {
     if (CatalogSnapshot &&
         ActiveSnapshot == NULL &&
         pairingheap_is_singular(&RegisteredSnapshots))
         InvalidateCatalogSnapshot();
 }

References ActiveSnapshot, CatalogSnapshot, InvalidateCatalogSnapshot(), pairingheap_is_singular, and RegisteredSnapshots.

Referenced by PostgresMain().

◆ MaintainOldSnapshotTimeMapping()

void MaintainOldSnapshotTimeMapping	(	TimestampTz	whenTaken,
		TransactionId	xmin
	)

Definition at line 1903 of file snapmgr.c.

 {
     TimestampTz ts;
     TransactionId latest_xmin;
     TimestampTz update_ts;
     bool        map_update_required = false;
  
     /* Never call this function when old snapshot checking is disabled. */
     Assert(old_snapshot_threshold >= 0);
  
     ts = AlignTimestampToMinuteBoundary(whenTaken);
  
     /*
      * Keep track of the latest xmin seen by any process. Update mapping with
      * a new value when we have crossed a bucket boundary.
      */
     SpinLockAcquire(&oldSnapshotControl->mutex_latest_xmin);
     latest_xmin = oldSnapshotControl->latest_xmin;
     update_ts = oldSnapshotControl->next_map_update;
     if (ts > update_ts)
     {
         oldSnapshotControl->next_map_update = ts;
         map_update_required = true;
     }
     if (TransactionIdFollows(xmin, latest_xmin))
         oldSnapshotControl->latest_xmin = xmin;
     SpinLockRelease(&oldSnapshotControl->mutex_latest_xmin);
  
     /* We only needed to update the most recent xmin value. */
     if (!map_update_required)
         return;
  
     /* No further tracking needed for 0 (used for testing). */
     if (old_snapshot_threshold == 0)
         return;
  
     /*
      * We don't want to do something stupid with unusual values, but we don't
      * want to litter the log with warnings or break otherwise normal
      * processing for this feature; so if something seems unreasonable, just
      * log at DEBUG level and return without doing anything.
      */
     if (whenTaken < 0)
     {
         elog(DEBUG1,
              "MaintainOldSnapshotTimeMapping called with negative whenTaken = %ld",
              (long) whenTaken);
         return;
     }
     if (!TransactionIdIsNormal(xmin))
     {
         elog(DEBUG1,
              "MaintainOldSnapshotTimeMapping called with xmin = %lu",
              (unsigned long) xmin);
         return;
     }
  
     LWLockAcquire(OldSnapshotTimeMapLock, LW_EXCLUSIVE);
  
     Assert(oldSnapshotControl->head_offset >= 0);
     Assert(oldSnapshotControl->head_offset < OLD_SNAPSHOT_TIME_MAP_ENTRIES);
     Assert((oldSnapshotControl->head_timestamp % USECS_PER_MINUTE) == 0);
     Assert(oldSnapshotControl->count_used >= 0);
     Assert(oldSnapshotControl->count_used <= OLD_SNAPSHOT_TIME_MAP_ENTRIES);
  
     if (oldSnapshotControl->count_used == 0)
     {
         /* set up first entry for empty mapping */
         oldSnapshotControl->head_offset = 0;
         oldSnapshotControl->head_timestamp = ts;
         oldSnapshotControl->count_used = 1;
         oldSnapshotControl->xid_by_minute[0] = xmin;
     }
     else if (ts < oldSnapshotControl->head_timestamp)
     {
         /* old ts; log it at DEBUG */
         LWLockRelease(OldSnapshotTimeMapLock);
         elog(DEBUG1,
              "MaintainOldSnapshotTimeMapping called with old whenTaken = %ld",
              (long) whenTaken);
         return;
     }
     else if (ts <= (oldSnapshotControl->head_timestamp +
                     ((oldSnapshotControl->count_used - 1)
                      * USECS_PER_MINUTE)))
     {
         /* existing mapping; advance xid if possible */
         int         bucket = (oldSnapshotControl->head_offset
                               + ((ts - oldSnapshotControl->head_timestamp)
                                  / USECS_PER_MINUTE))
         % OLD_SNAPSHOT_TIME_MAP_ENTRIES;
  
         if (TransactionIdPrecedes(oldSnapshotControl->xid_by_minute[bucket], xmin))
             oldSnapshotControl->xid_by_minute[bucket] = xmin;
     }
     else
     {
         /* We need a new bucket, but it might not be the very next one. */
         int         distance_to_new_tail;
         int         distance_to_current_tail;
         int         advance;
  
         /*
          * Our goal is for the new "tail" of the mapping, that is, the entry
          * which is newest and thus furthest from the "head" entry, to
          * correspond to "ts". Since there's one entry per minute, the
          * distance between the current head and the new tail is just the
          * number of minutes of difference between ts and the current
          * head_timestamp.
          *
          * The distance from the current head to the current tail is one less
          * than the number of entries in the mapping, because the entry at the
          * head_offset is for 0 minutes after head_timestamp.
          *
          * The difference between these two values is the number of minutes by
          * which we need to advance the mapping, either adding new entries or
          * rotating old ones out.
          */
         distance_to_new_tail =
             (ts - oldSnapshotControl->head_timestamp) / USECS_PER_MINUTE;
         distance_to_current_tail =
             oldSnapshotControl->count_used - 1;
         advance = distance_to_new_tail - distance_to_current_tail;
         Assert(advance > 0);
  
         if (advance >= OLD_SNAPSHOT_TIME_MAP_ENTRIES)
         {
             /* Advance is so far that all old data is junk; start over. */
             oldSnapshotControl->head_offset = 0;
             oldSnapshotControl->count_used = 1;
             oldSnapshotControl->xid_by_minute[0] = xmin;
             oldSnapshotControl->head_timestamp = ts;
         }
         else
         {
             /* Store the new value in one or more buckets. */
             int         i;
  
             for (i = 0; i < advance; i++)
             {
                 if (oldSnapshotControl->count_used == OLD_SNAPSHOT_TIME_MAP_ENTRIES)
                 {
                     /* Map full and new value replaces old head. */
                     int         old_head = oldSnapshotControl->head_offset;
  
                     if (old_head == (OLD_SNAPSHOT_TIME_MAP_ENTRIES - 1))
                         oldSnapshotControl->head_offset = 0;
                     else
                         oldSnapshotControl->head_offset = old_head + 1;
                     oldSnapshotControl->xid_by_minute[old_head] = xmin;
                     oldSnapshotControl->head_timestamp += USECS_PER_MINUTE;
                 }
                 else
                 {
                     /* Extend map to unused entry. */
                     int         new_tail = (oldSnapshotControl->head_offset
                                             + oldSnapshotControl->count_used)
                     % OLD_SNAPSHOT_TIME_MAP_ENTRIES;
  
                     oldSnapshotControl->count_used++;
                     oldSnapshotControl->xid_by_minute[new_tail] = xmin;
                 }
             }
         }
     }
  
     LWLockRelease(OldSnapshotTimeMapLock);
 }

References AlignTimestampToMinuteBoundary(), Assert(), OldSnapshotControlData::count_used, DEBUG1, elog(), OldSnapshotControlData::head_offset, OldSnapshotControlData::head_timestamp, i, OldSnapshotControlData::latest_xmin, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OldSnapshotControlData::mutex_latest_xmin, OldSnapshotControlData::next_map_update, old_snapshot_threshold, OLD_SNAPSHOT_TIME_MAP_ENTRIES, oldSnapshotControl, SpinLockAcquire, SpinLockRelease, TransactionIdFollows(), TransactionIdIsNormal, TransactionIdPrecedes(), USECS_PER_MINUTE, and OldSnapshotControlData::xid_by_minute.

Referenced by GetSnapshotDataInitOldSnapshot().

◆ OldSnapshotThresholdActive()

static bool OldSnapshotThresholdActive ( void )

inlinestatic

Definition at line 102 of file snapmgr.h.

 {
     return old_snapshot_threshold >= 0;
 }

References old_snapshot_threshold.

Referenced by GetSnapshotDataInitOldSnapshot(), heap_page_prune_opt(), heap_prune_satisfies_vacuum(), TransactionIdLimitedForOldSnapshots(), and vacuum_get_cutoffs().

◆ PopActiveSnapshot()

void PopActiveSnapshot ( void )

Definition at line 778 of file snapmgr.c.

 {
     ActiveSnapshotElt *newstack;
  
     newstack = ActiveSnapshot->as_next;
  
     Assert(ActiveSnapshot->as_snap->active_count > 0);
  
     ActiveSnapshot->as_snap->active_count--;
  
     if (ActiveSnapshot->as_snap->active_count == 0 &&
         ActiveSnapshot->as_snap->regd_count == 0)
         FreeSnapshot(ActiveSnapshot->as_snap);
  
     pfree(ActiveSnapshot);
     ActiveSnapshot = newstack;
     if (ActiveSnapshot == NULL)
         OldestActiveSnapshot = NULL;
  
     SnapshotResetXmin();
 }

References SnapshotData::active_count, ActiveSnapshot, ActiveSnapshotElt::as_next, ActiveSnapshotElt::as_snap, Assert(), FreeSnapshot(), OldestActiveSnapshot, pfree(), SnapshotData::regd_count, and SnapshotResetXmin().

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), ATExecDetachPartition(), BuildCachedPlan(), cluster_multiple_rels(), DefineIndex(), DoPortalRewind(), end_replication_step(), EndCopyTo(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), ExecCreateTableAs(), execute_sql_string(), ExecuteCallStmt(), ExplainOnePlan(), fmgr_sql(), ForgetPortalSnapshots(), HandleFunctionRequest(), index_drop(), initialize_worker_spi(), LogicalRepSyncTableStart(), movedb(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunMulti(), PortalRunSelect(), PortalRunUtility(), PortalStart(), refresh_matview_datafill(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ShutdownSQLFunction(), vacuum(), and vacuum_rel().

◆ PushActiveSnapshot()

void PushActiveSnapshot ( Snapshot snapshot )

Definition at line 683 of file snapmgr.c.

 {
     PushActiveSnapshotWithLevel(snapshot, GetCurrentTransactionNestLevel());
 }

References GetCurrentTransactionNestLevel(), and PushActiveSnapshotWithLevel().

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), begin_replication_step(), BuildCachedPlan(), cluster_multiple_rels(), DefineIndex(), DoPortalRewind(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), ExecuteCallStmt(), fmgr_sql(), HandleFunctionRequest(), initialize_worker_spi(), LogicalRepSyncTableStart(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunSelect(), PortalStart(), PushCopiedSnapshot(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ShutdownSQLFunction(), vacuum(), and vacuum_rel().

◆ PushActiveSnapshotWithLevel()

void PushActiveSnapshotWithLevel	(	Snapshot	snapshot,
		int	snap_level
	)

Definition at line 697 of file snapmgr.c.

 {
     ActiveSnapshotElt *newactive;
  
     Assert(snapshot != InvalidSnapshot);
     Assert(ActiveSnapshot == NULL || snap_level >= ActiveSnapshot->as_level);
  
     newactive = MemoryContextAlloc(TopTransactionContext, sizeof(ActiveSnapshotElt));
  
     /*
      * Checking SecondarySnapshot is probably useless here, but it seems
      * better to be sure.
      */
     if (snapshot == CurrentSnapshot || snapshot == SecondarySnapshot ||
         !snapshot->copied)
         newactive->as_snap = CopySnapshot(snapshot);
     else
         newactive->as_snap = snapshot;
  
     newactive->as_next = ActiveSnapshot;
     newactive->as_level = snap_level;
  
     newactive->as_snap->active_count++;
  
     ActiveSnapshot = newactive;
     if (OldestActiveSnapshot == NULL)
         OldestActiveSnapshot = ActiveSnapshot;
 }

References SnapshotData::active_count, ActiveSnapshot, ActiveSnapshotElt::as_level, ActiveSnapshotElt::as_next, ActiveSnapshotElt::as_snap, Assert(), SnapshotData::copied, CopySnapshot(), CurrentSnapshot, InvalidSnapshot, MemoryContextAlloc(), OldestActiveSnapshot, SecondarySnapshot, and TopTransactionContext.

Referenced by EnsurePortalSnapshotExists(), PortalRunUtility(), and PushActiveSnapshot().

◆ PushCopiedSnapshot()

void PushCopiedSnapshot ( Snapshot snapshot )

Definition at line 735 of file snapmgr.c.

 {
     PushActiveSnapshot(CopySnapshot(snapshot));
 }

References CopySnapshot(), and PushActiveSnapshot().

Referenced by _SPI_execute_plan(), BeginCopyTo(), ExecCreateTableAs(), ExplainOnePlan(), PortalRunMulti(), and refresh_matview_datafill().

◆ RegisterSnapshot()

Snapshot RegisterSnapshot ( Snapshot snapshot )

Definition at line 829 of file snapmgr.c.

 {
     if (snapshot == InvalidSnapshot)
         return InvalidSnapshot;
  
     return RegisterSnapshotOnOwner(snapshot, CurrentResourceOwner);
 }

References CurrentResourceOwner, InvalidSnapshot, and RegisterSnapshotOnOwner().

Referenced by _bt_begin_parallel(), AlterDomainNotNull(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), CreateQueryDesc(), currtid_internal(), DefineIndex(), heapam_index_build_range_scan(), index_beginscan_parallel(), IndexCheckExclusion(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), process_settings(), ReindexRelationConcurrently(), standard_ExecutorStart(), systable_beginscan(), systable_beginscan_ordered(), table_beginscan_catalog(), table_beginscan_parallel(), table_scan_update_snapshot(), validateDomainConstraint(), and validateForeignKeyConstraint().

◆ RegisterSnapshotOnOwner()

Snapshot RegisterSnapshotOnOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 842 of file snapmgr.c.

 {
     Snapshot    snap;
  
     if (snapshot == InvalidSnapshot)
         return InvalidSnapshot;
  
     /* Static snapshot?  Create a persistent copy */
     snap = snapshot->copied ? snapshot : CopySnapshot(snapshot);
  
     /* and tell resowner.c about it */
     ResourceOwnerEnlargeSnapshots(owner);
     snap->regd_count++;
     ResourceOwnerRememberSnapshot(owner, snap);
  
     if (snap->regd_count == 1)
         pairingheap_add(&RegisteredSnapshots, &snap->ph_node);
  
     return snap;
 }

References SnapshotData::copied, CopySnapshot(), InvalidSnapshot, pairingheap_add(), SnapshotData::ph_node, SnapshotData::regd_count, RegisteredSnapshots, ResourceOwnerEnlargeSnapshots(), and ResourceOwnerRememberSnapshot().

Referenced by be_lo_open(), and RegisterSnapshot().

◆ RestoreSnapshot()

Snapshot RestoreSnapshot ( char * start_address )

Definition at line 2206 of file snapmgr.c.

 {
     SerializedSnapshotData serialized_snapshot;
     Size        size;
     Snapshot    snapshot;
     TransactionId *serialized_xids;
  
     memcpy(&serialized_snapshot, start_address,
            sizeof(SerializedSnapshotData));
     serialized_xids = (TransactionId *)
         (start_address + sizeof(SerializedSnapshotData));
  
     /* We allocate any XID arrays needed in the same palloc block. */
     size = sizeof(SnapshotData)
         + serialized_snapshot.xcnt * sizeof(TransactionId)
         + serialized_snapshot.subxcnt * sizeof(TransactionId);
  
     /* Copy all required fields */
     snapshot = (Snapshot) MemoryContextAlloc(TopTransactionContext, size);
     snapshot->snapshot_type = SNAPSHOT_MVCC;
     snapshot->xmin = serialized_snapshot.xmin;
     snapshot->xmax = serialized_snapshot.xmax;
     snapshot->xip = NULL;
     snapshot->xcnt = serialized_snapshot.xcnt;
     snapshot->subxip = NULL;
     snapshot->subxcnt = serialized_snapshot.subxcnt;
     snapshot->suboverflowed = serialized_snapshot.suboverflowed;
     snapshot->takenDuringRecovery = serialized_snapshot.takenDuringRecovery;
     snapshot->curcid = serialized_snapshot.curcid;
     snapshot->whenTaken = serialized_snapshot.whenTaken;
     snapshot->lsn = serialized_snapshot.lsn;
     snapshot->snapXactCompletionCount = 0;
  
     /* Copy XIDs, if present. */
     if (serialized_snapshot.xcnt > 0)
     {
         snapshot->xip = (TransactionId *) (snapshot + 1);
         memcpy(snapshot->xip, serialized_xids,
                serialized_snapshot.xcnt * sizeof(TransactionId));
     }
  
     /* Copy SubXIDs, if present. */
     if (serialized_snapshot.subxcnt > 0)
     {
         snapshot->subxip = ((TransactionId *) (snapshot + 1)) +
             serialized_snapshot.xcnt;
         memcpy(snapshot->subxip, serialized_xids + serialized_snapshot.xcnt,
                serialized_snapshot.subxcnt * sizeof(TransactionId));
     }
  
     /* Set the copied flag so that the caller will set refcounts correctly. */
     snapshot->regd_count = 0;
     snapshot->active_count = 0;
     snapshot->copied = true;
  
     return snapshot;
 }

Referenced by ExecBitmapHeapInitializeWorker(), index_beginscan_parallel(), ParallelWorkerMain(), and table_beginscan_parallel().

◆ RestoreTransactionSnapshot()

void RestoreTransactionSnapshot	(	Snapshot	snapshot,
		void *	source_pgproc
	)

Definition at line 2271 of file snapmgr.c.

 {
     SetTransactionSnapshot(snapshot, NULL, InvalidPid, source_pgproc);
 }

References InvalidPid, and SetTransactionSnapshot().

Referenced by CreateReplicationSlot(), and ParallelWorkerMain().

◆ SerializeSnapshot()

void SerializeSnapshot	(	Snapshot	snapshot,
		char *	start_address
	)

Definition at line 2147 of file snapmgr.c.

 {
     SerializedSnapshotData serialized_snapshot;
  
     Assert(snapshot->subxcnt >= 0);
  
     /* Copy all required fields */
     serialized_snapshot.xmin = snapshot->xmin;
     serialized_snapshot.xmax = snapshot->xmax;
     serialized_snapshot.xcnt = snapshot->xcnt;
     serialized_snapshot.subxcnt = snapshot->subxcnt;
     serialized_snapshot.suboverflowed = snapshot->suboverflowed;
     serialized_snapshot.takenDuringRecovery = snapshot->takenDuringRecovery;
     serialized_snapshot.curcid = snapshot->curcid;
     serialized_snapshot.whenTaken = snapshot->whenTaken;
     serialized_snapshot.lsn = snapshot->lsn;
  
     /*
      * Ignore the SubXID array if it has overflowed, unless the snapshot was
      * taken during recovery - in that case, top-level XIDs are in subxip as
      * well, and we mustn't lose them.
      */
     if (serialized_snapshot.suboverflowed && !snapshot->takenDuringRecovery)
         serialized_snapshot.subxcnt = 0;
  
     /* Copy struct to possibly-unaligned buffer */
     memcpy(start_address,
            &serialized_snapshot, sizeof(SerializedSnapshotData));
  
     /* Copy XID array */
     if (snapshot->xcnt > 0)
         memcpy((TransactionId *) (start_address +
                                   sizeof(SerializedSnapshotData)),
                snapshot->xip, snapshot->xcnt * sizeof(TransactionId));
  
     /*
      * Copy SubXID array. Don't bother to copy it if it had overflowed,
      * though, because it's not used anywhere in that case. Except if it's a
      * snapshot taken during recovery; all the top-level XIDs are in subxip as
      * well in that case, so we mustn't lose them.
      */
     if (serialized_snapshot.subxcnt > 0)
     {
         Size        subxipoff = sizeof(SerializedSnapshotData) +
         snapshot->xcnt * sizeof(TransactionId);
  
         memcpy((TransactionId *) (start_address + subxipoff),
                snapshot->subxip, snapshot->subxcnt * sizeof(TransactionId));
     }
 }

Referenced by ExecBitmapHeapInitializeDSM(), index_parallelscan_initialize(), InitializeParallelDSM(), and table_parallelscan_initialize().

◆ SetOldSnapshotThresholdTimestamp()

void SetOldSnapshotThresholdTimestamp	(	TimestampTz	ts,
		TransactionId	xlimit
	)

Definition at line 1717 of file snapmgr.c.

 {
     SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
     Assert(oldSnapshotControl->threshold_timestamp <= ts);
     Assert(TransactionIdPrecedesOrEquals(oldSnapshotControl->threshold_xid, xlimit));
     oldSnapshotControl->threshold_timestamp = ts;
     oldSnapshotControl->threshold_xid = xlimit;
     SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 }

References Assert(), OldSnapshotControlData::mutex_threshold, oldSnapshotControl, SpinLockAcquire, SpinLockRelease, OldSnapshotControlData::threshold_timestamp, OldSnapshotControlData::threshold_xid, and TransactionIdPrecedesOrEquals().

Referenced by heap_prune_satisfies_vacuum(), and vacuum_get_cutoffs().

◆ SetupHistoricSnapshot()

void SetupHistoricSnapshot	(	Snapshot	historic_snapshot,
		struct HTAB *	tuplecids
	)

Definition at line 2080 of file snapmgr.c.

 {
     Assert(historic_snapshot != NULL);
  
     /* setup the timetravel snapshot */
     HistoricSnapshot = historic_snapshot;
  
     /* setup (cmin, cmax) lookup hash */
     tuplecid_data = tuplecids;
 }

References Assert(), HistoricSnapshot, and tuplecid_data.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

◆ SnapMgrInit()

void SnapMgrInit ( void )

Definition at line 214 of file snapmgr.c.

 {
     bool        found;
  
     /*
      * Create or attach to the OldSnapshotControlData structure.
      */
     oldSnapshotControl = (volatile OldSnapshotControlData *)
         ShmemInitStruct("OldSnapshotControlData",
                         SnapMgrShmemSize(), &found);
  
     if (!found)
     {
         SpinLockInit(&oldSnapshotControl->mutex_current);
         oldSnapshotControl->current_timestamp = 0;
         SpinLockInit(&oldSnapshotControl->mutex_latest_xmin);
         oldSnapshotControl->latest_xmin = InvalidTransactionId;
         oldSnapshotControl->next_map_update = 0;
         SpinLockInit(&oldSnapshotControl->mutex_threshold);
         oldSnapshotControl->threshold_timestamp = 0;
         oldSnapshotControl->threshold_xid = InvalidTransactionId;
         oldSnapshotControl->head_offset = 0;
         oldSnapshotControl->head_timestamp = 0;
         oldSnapshotControl->count_used = 0;
     }
 }

Referenced by CreateSharedMemoryAndSemaphores().

◆ SnapMgrShmemSize()

Size SnapMgrShmemSize ( void )

Definition at line 198 of file snapmgr.c.

 {
     Size        size;
  
     size = offsetof(OldSnapshotControlData, xid_by_minute);
     if (old_snapshot_threshold > 0)
         size = add_size(size, mul_size(sizeof(TransactionId),
                                        OLD_SNAPSHOT_TIME_MAP_ENTRIES));
  
     return size;
 }

References add_size(), mul_size(), old_snapshot_threshold, and OLD_SNAPSHOT_TIME_MAP_ENTRIES.

Referenced by CalculateShmemSize(), and SnapMgrInit().

◆ SnapshotSetCommandId()

void SnapshotSetCommandId ( CommandId curcid )

Definition at line 491 of file snapmgr.c.

 {
     if (!FirstSnapshotSet)
         return;
  
     if (CurrentSnapshot)
         CurrentSnapshot->curcid = curcid;
     if (SecondarySnapshot)
         SecondarySnapshot->curcid = curcid;
     /* Should we do the same with CatalogSnapshot? */
 }

References SnapshotData::curcid, CurrentSnapshot, FirstSnapshotSet, and SecondarySnapshot.

Referenced by CommandCounterIncrement().

◆ SnapshotTooOldMagicForTest()

void SnapshotTooOldMagicForTest ( void )

Definition at line 1734 of file snapmgr.c.

 {
     TimestampTz ts = GetSnapshotCurrentTimestamp();
  
     Assert(old_snapshot_threshold == 0);
  
     ts -= 5 * USECS_PER_SEC;
  
     SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
     oldSnapshotControl->threshold_timestamp = ts;
     SpinLockRelease(&oldSnapshotControl->mutex_threshold);
 }

References Assert(), GetSnapshotCurrentTimestamp(), OldSnapshotControlData::mutex_threshold, old_snapshot_threshold, oldSnapshotControl, SpinLockAcquire, SpinLockRelease, OldSnapshotControlData::threshold_timestamp, and USECS_PER_SEC.

Referenced by heap_page_prune_opt().

◆ TeardownHistoricSnapshot()

void TeardownHistoricSnapshot ( bool is_error )

Definition at line 2096 of file snapmgr.c.

 {
     HistoricSnapshot = NULL;
     tuplecid_data = NULL;
 }

References HistoricSnapshot, and tuplecid_data.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

◆ ThereAreNoPriorRegisteredSnapshots()

bool ThereAreNoPriorRegisteredSnapshots ( void )

Definition at line 1623 of file snapmgr.c.

 {
     if (pairingheap_is_empty(&RegisteredSnapshots) ||
         pairingheap_is_singular(&RegisteredSnapshots))
         return true;
  
     return false;
 }

References pairingheap_is_empty, pairingheap_is_singular, and RegisteredSnapshots.

Referenced by CopyFrom().

◆ TransactionIdLimitedForOldSnapshots()

bool TransactionIdLimitedForOldSnapshots	(	TransactionId	recentXmin,
		Relation	relation,
		TransactionId *	limit_xid,
		TimestampTz *	limit_ts
	)

Definition at line 1796 of file snapmgr.c.

 {
     TimestampTz ts;
     TransactionId xlimit = recentXmin;
     TransactionId latest_xmin;
     TimestampTz next_map_update_ts;
     TransactionId threshold_timestamp;
     TransactionId threshold_xid;
  
     Assert(TransactionIdIsNormal(recentXmin));
     Assert(OldSnapshotThresholdActive());
     Assert(limit_ts != NULL && limit_xid != NULL);
  
     /*
      * TestForOldSnapshot() assumes early pruning advances the page LSN, so we
      * can't prune early when skipping WAL.
      */
     if (!RelationAllowsEarlyPruning(relation) || !RelationNeedsWAL(relation))
         return false;
  
     ts = GetSnapshotCurrentTimestamp();
  
     SpinLockAcquire(&oldSnapshotControl->mutex_latest_xmin);
     latest_xmin = oldSnapshotControl->latest_xmin;
     next_map_update_ts = oldSnapshotControl->next_map_update;
     SpinLockRelease(&oldSnapshotControl->mutex_latest_xmin);
  
     /*
      * Zero threshold always overrides to latest xmin, if valid.  Without some
      * heuristic it will find its own snapshot too old on, for example, a
      * simple UPDATE -- which would make it useless for most testing, but
      * there is no principled way to ensure that it doesn't fail in this way.
      * Use a five-second delay to try to get useful testing behavior, but this
      * may need adjustment.
      */
     if (old_snapshot_threshold == 0)
     {
         if (TransactionIdPrecedes(latest_xmin, MyProc->xmin)
             && TransactionIdFollows(latest_xmin, xlimit))
             xlimit = latest_xmin;
  
         ts -= 5 * USECS_PER_SEC;
     }
     else
     {
         ts = AlignTimestampToMinuteBoundary(ts)
             - (old_snapshot_threshold * USECS_PER_MINUTE);
  
         /* Check for fast exit without LW locking. */
         SpinLockAcquire(&oldSnapshotControl->mutex_threshold);
         threshold_timestamp = oldSnapshotControl->threshold_timestamp;
         threshold_xid = oldSnapshotControl->threshold_xid;
         SpinLockRelease(&oldSnapshotControl->mutex_threshold);
  
         if (ts == threshold_timestamp)
         {
             /*
              * Current timestamp is in same bucket as the last limit that was
              * applied. Reuse.
              */
             xlimit = threshold_xid;
         }
         else if (ts == next_map_update_ts)
         {
             /*
              * FIXME: This branch is super iffy - but that should probably
              * fixed separately.
              */
             xlimit = latest_xmin;
         }
         else if (GetOldSnapshotFromTimeMapping(ts, &xlimit))
         {
         }
  
         /*
          * Failsafe protection against vacuuming work of active transaction.
          *
          * This is not an assertion because we avoid the spinlock for
          * performance, leaving open the possibility that xlimit could advance
          * and be more current; but it seems prudent to apply this limit.  It
          * might make pruning a tiny bit less aggressive than it could be, but
          * protects against data loss bugs.
          */
         if (TransactionIdIsNormal(latest_xmin)
             && TransactionIdPrecedes(latest_xmin, xlimit))
             xlimit = latest_xmin;
     }
  
     if (TransactionIdIsValid(xlimit) &&
         TransactionIdFollowsOrEquals(xlimit, recentXmin))
     {
         *limit_ts = ts;
         *limit_xid = xlimit;
  
         return true;
     }
  
     return false;
 }

References AlignTimestampToMinuteBoundary(), Assert(), GetOldSnapshotFromTimeMapping(), GetSnapshotCurrentTimestamp(), OldSnapshotControlData::latest_xmin, OldSnapshotControlData::mutex_latest_xmin, OldSnapshotControlData::mutex_threshold, MyProc, OldSnapshotControlData::next_map_update, old_snapshot_threshold, oldSnapshotControl, OldSnapshotThresholdActive(), RelationAllowsEarlyPruning, RelationNeedsWAL, SpinLockAcquire, SpinLockRelease, OldSnapshotControlData::threshold_timestamp, OldSnapshotControlData::threshold_xid, TransactionIdFollows(), TransactionIdFollowsOrEquals(), TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), USECS_PER_MINUTE, USECS_PER_SEC, and PGPROC::xmin.

Referenced by heap_page_prune_opt(), heap_prune_satisfies_vacuum(), and vacuum_get_cutoffs().

◆ UnregisterSnapshot()

void UnregisterSnapshot ( Snapshot snapshot )

Definition at line 871 of file snapmgr.c.

 {
     if (snapshot == NULL)
         return;
  
     UnregisterSnapshotFromOwner(snapshot, CurrentResourceOwner);
 }

References CurrentResourceOwner, and UnregisterSnapshotFromOwner().

Referenced by _bt_begin_parallel(), _bt_end_parallel(), AlterDomainNotNull(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), currtid_internal(), DefineIndex(), FreeQueryDesc(), heap_endscan(), heapam_index_build_range_scan(), index_endscan(), IndexCheckExclusion(), pg_get_constraintdef_worker(), process_settings(), ReindexRelationConcurrently(), ResourceOwnerReleaseInternal(), standard_ExecutorEnd(), systable_endscan(), systable_endscan_ordered(), validateDomainConstraint(), and validateForeignKeyConstraint().

◆ UnregisterSnapshotFromOwner()

void UnregisterSnapshotFromOwner	(	Snapshot	snapshot,
		ResourceOwner	owner
	)

Definition at line 884 of file snapmgr.c.

 {
     if (snapshot == NULL)
         return;
  
     Assert(snapshot->regd_count > 0);
     Assert(!pairingheap_is_empty(&RegisteredSnapshots));
  
     ResourceOwnerForgetSnapshot(owner, snapshot);
  
     snapshot->regd_count--;
     if (snapshot->regd_count == 0)
         pairingheap_remove(&RegisteredSnapshots, &snapshot->ph_node);
  
     if (snapshot->regd_count == 0 && snapshot->active_count == 0)
     {
         FreeSnapshot(snapshot);
         SnapshotResetXmin();
     }
 }

References SnapshotData::active_count, Assert(), FreeSnapshot(), pairingheap_is_empty, pairingheap_remove(), SnapshotData::ph_node, SnapshotData::regd_count, RegisteredSnapshots, ResourceOwnerForgetSnapshot(), and SnapshotResetXmin().

Referenced by closeLOfd(), PortalDrop(), PreCommit_Portals(), and UnregisterSnapshot().

◆ UpdateActiveSnapshotCommandId()

void UpdateActiveSnapshotCommandId ( void )

Definition at line 747 of file snapmgr.c.

 {
     CommandId   save_curcid,
                 curcid;
  
     Assert(ActiveSnapshot != NULL);
     Assert(ActiveSnapshot->as_snap->active_count == 1);
     Assert(ActiveSnapshot->as_snap->regd_count == 0);
  
     /*
      * Don't allow modification of the active snapshot during parallel
      * operation.  We share the snapshot to worker backends at the beginning
      * of parallel operation, so any change to the snapshot can lead to
      * inconsistencies.  We have other defenses against
      * CommandCounterIncrement, but there are a few places that call this
      * directly, so we put an additional guard here.
      */
     save_curcid = ActiveSnapshot->as_snap->curcid;
     curcid = GetCurrentCommandId(false);
     if (IsInParallelMode() && save_curcid != curcid)
         elog(ERROR, "cannot modify commandid in active snapshot during a parallel operation");
     ActiveSnapshot->as_snap->curcid = curcid;
 }

References SnapshotData::active_count, ActiveSnapshot, ActiveSnapshotElt::as_snap, Assert(), SnapshotData::curcid, elog(), ERROR, GetCurrentCommandId(), IsInParallelMode(), and SnapshotData::regd_count.

Referenced by _SPI_execute_plan(), BeginCopyTo(), ExecCreateTableAs(), ExplainOnePlan(), fmgr_sql(), PortalRunMulti(), and refresh_matview_datafill().

◆ WaitForOlderSnapshots()

void WaitForOlderSnapshots	(	TransactionId	limitXmin,
		bool	progress
	)

Definition at line 423 of file indexcmds.c.

 {
     int         n_old_snapshots;
     int         i;
     VirtualTransactionId *old_snapshots;
  
     old_snapshots = GetCurrentVirtualXIDs(limitXmin, true, false,
                                           PROC_IS_AUTOVACUUM | PROC_IN_VACUUM
                                           | PROC_IN_SAFE_IC,
                                           &n_old_snapshots);
     if (progress)
         pgstat_progress_update_param(PROGRESS_WAITFOR_TOTAL, n_old_snapshots);
  
     for (i = 0; i < n_old_snapshots; i++)
     {
         if (!VirtualTransactionIdIsValid(old_snapshots[i]))
             continue;           /* found uninteresting in previous cycle */
  
         if (i > 0)
         {
             /* see if anything's changed ... */
             VirtualTransactionId *newer_snapshots;
             int         n_newer_snapshots;
             int         j;
             int         k;
  
             newer_snapshots = GetCurrentVirtualXIDs(limitXmin,
                                                     true, false,
                                                     PROC_IS_AUTOVACUUM | PROC_IN_VACUUM
                                                     | PROC_IN_SAFE_IC,
                                                     &n_newer_snapshots);
             for (j = i; j < n_old_snapshots; j++)
             {
                 if (!VirtualTransactionIdIsValid(old_snapshots[j]))
                     continue;   /* found uninteresting in previous cycle */
                 for (k = 0; k < n_newer_snapshots; k++)
                 {
                     if (VirtualTransactionIdEquals(old_snapshots[j],
                                                    newer_snapshots[k]))
                         break;
                 }
                 if (k >= n_newer_snapshots) /* not there anymore */
                     SetInvalidVirtualTransactionId(old_snapshots[j]);
             }
             pfree(newer_snapshots);
         }
  
         if (VirtualTransactionIdIsValid(old_snapshots[i]))
         {
             /* If requested, publish who we're going to wait for. */
             if (progress)
             {
                 PGPROC     *holder = BackendIdGetProc(old_snapshots[i].backendId);
  
                 if (holder)
                     pgstat_progress_update_param(PROGRESS_WAITFOR_CURRENT_PID,
                                                  holder->pid);
             }
             VirtualXactLock(old_snapshots[i], true);
         }
  
         if (progress)
             pgstat_progress_update_param(PROGRESS_WAITFOR_DONE, i + 1);
     }
 }

References BackendIdGetProc(), GetCurrentVirtualXIDs(), i, j, pfree(), pgstat_progress_update_param(), PGPROC::pid, PROC_IN_SAFE_IC, PROC_IN_VACUUM, PROC_IS_AUTOVACUUM, progress, PROGRESS_WAITFOR_CURRENT_PID, PROGRESS_WAITFOR_DONE, PROGRESS_WAITFOR_TOTAL, SetInvalidVirtualTransactionId, VirtualTransactionIdEquals, VirtualTransactionIdIsValid, and VirtualXactLock().

Referenced by ATExecDetachPartitionFinalize(), DefineIndex(), and ReindexRelationConcurrently().

◆ XactHasExportedSnapshots()

bool XactHasExportedSnapshots ( void )

Definition at line 1571 of file snapmgr.c.

 {
     return (exportedSnapshots != NIL);
 }

References exportedSnapshots, and NIL.

Referenced by PrepareTransaction().

◆ XidInMVCCSnapshot()

bool XidInMVCCSnapshot	(	TransactionId	xid,
		Snapshot	snapshot
	)

Definition at line 2287 of file snapmgr.c.

 {
     /*
      * Make a quick range check to eliminate most XIDs without looking at the
      * xip arrays.  Note that this is OK even if we convert a subxact XID to
      * its parent below, because a subxact with XID < xmin has surely also got
      * a parent with XID < xmin, while one with XID >= xmax must belong to a
      * parent that was not yet committed at the time of this snapshot.
      */
  
     /* Any xid < xmin is not in-progress */
     if (TransactionIdPrecedes(xid, snapshot->xmin))
         return false;
     /* Any xid >= xmax is in-progress */
     if (TransactionIdFollowsOrEquals(xid, snapshot->xmax))
         return true;
  
     /*
      * Snapshot information is stored slightly differently in snapshots taken
      * during recovery.
      */
     if (!snapshot->takenDuringRecovery)
     {
         /*
          * If the snapshot contains full subxact data, the fastest way to
          * check things is just to compare the given XID against both subxact
          * XIDs and top-level XIDs.  If the snapshot overflowed, we have to
          * use pg_subtrans to convert a subxact XID to its parent XID, but
          * then we need only look at top-level XIDs not subxacts.
          */
         if (!snapshot->suboverflowed)
         {
             /* we have full data, so search subxip */
             if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
                 return true;
  
             /* not there, fall through to search xip[] */
         }
         else
         {
             /*
              * Snapshot overflowed, so convert xid to top-level.  This is safe
              * because we eliminated too-old XIDs above.
              */
             xid = SubTransGetTopmostTransaction(xid);
  
             /*
              * If xid was indeed a subxact, we might now have an xid < xmin,
              * so recheck to avoid an array scan.  No point in rechecking
              * xmax.
              */
             if (TransactionIdPrecedes(xid, snapshot->xmin))
                 return false;
         }
  
         if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
             return true;
     }
     else
     {
         /*
          * In recovery we store all xids in the subxip array because it is by
          * far the bigger array, and we mostly don't know which xids are
          * top-level and which are subxacts. The xip array is empty.
          *
          * We start by searching subtrans, if we overflowed.
          */
         if (snapshot->suboverflowed)
         {
             /*
              * Snapshot overflowed, so convert xid to top-level.  This is safe
              * because we eliminated too-old XIDs above.
              */
             xid = SubTransGetTopmostTransaction(xid);
  
             /*
              * If xid was indeed a subxact, we might now have an xid < xmin,
              * so recheck to avoid an array scan.  No point in rechecking
              * xmax.
              */
             if (TransactionIdPrecedes(xid, snapshot->xmin))
                 return false;
         }
  
         /*
          * We now have either a top-level xid higher than xmin or an
          * indeterminate xid. We don't know whether it's top level or subxact
          * but it doesn't matter. If it's present, the xid is visible.
          */
         if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
             return true;
     }
  
     return false;
 }

References pg_lfind32(), SnapshotData::suboverflowed, SubTransGetTopmostTransaction(), SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TransactionIdFollowsOrEquals(), TransactionIdPrecedes(), SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by asyncQueueProcessPageEntries(), find_inheritance_children_extended(), HeapTupleSatisfiesMVCC(), and RelationGetPartitionDesc().

Variable Documentation

◆ CatalogSnapshotData

PGDLLIMPORT SnapshotData CatalogSnapshotData

extern

Definition at line 98 of file snapmgr.c.

Referenced by GetNonHistoricCatalogSnapshot().

◆ FirstSnapshotSet

PGDLLIMPORT bool FirstSnapshotSet

extern

Definition at line 150 of file snapmgr.c.

Referenced by AtEOXact_Snapshot(), check_transaction_deferrable(), check_transaction_isolation(), check_transaction_read_only(), CreateReplicationSlot(), GetLatestSnapshot(), GetTransactionSnapshot(), ImportSnapshot(), SetTransactionSnapshot(), and SnapshotSetCommandId().

◆ old_snapshot_threshold

PGDLLIMPORT int old_snapshot_threshold

extern

Definition at line 79 of file snapmgr.c.

Referenced by heap_page_prune_opt(), MaintainOldSnapshotTimeMapping(), OldSnapshotThresholdActive(), should_attempt_truncation(), SnapMgrShmemSize(), SnapshotTooOldMagicForTest(), TestForOldSnapshot(), and TransactionIdLimitedForOldSnapshots().

◆ RecentXmin

PGDLLIMPORT TransactionId RecentXmin

extern

Definition at line 114 of file snapmgr.c.

Referenced by ATRewriteTables(), bt_check_every_level(), GetSnapshotData(), GetSnapshotDataReuse(), GlobalVisTestFor(), GlobalVisTestShouldUpdate(), GlobalVisUpdateApply(), heap_hot_search_buffer(), heapam_relation_set_new_filelocator(), index_getnext_tid(), refresh_by_heap_swap(), TransactionIdIsActive(), and TransactionIdIsInProgress().

◆ SnapshotAnyData

PGDLLIMPORT SnapshotData SnapshotAnyData

extern

Definition at line 100 of file snapmgr.c.

◆ SnapshotSelfData

PGDLLIMPORT SnapshotData SnapshotSelfData

extern

Definition at line 99 of file snapmgr.c.

◆ TransactionXmin

PGDLLIMPORT TransactionId TransactionXmin

extern

Definition at line 113 of file snapmgr.c.

Referenced by BuildCachedPlan(), CheckCachedPlan(), get_relation_info(), GetSnapshotData(), GetSnapshotDataReuse(), heap_abort_speculative(), HeapCheckForSerializableConflictOut(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), SubTransGetParent(), SubTransGetTopmostTransaction(), TransactionIdDidAbort(), and TransactionIdDidCommit().

Variables
PGDLLIMPORT int	old_snapshot_threshold

PGDLLIMPORT bool	FirstSnapshotSet

PGDLLIMPORT TransactionId	TransactionXmin

PGDLLIMPORT TransactionId	RecentXmin

PGDLLIMPORT SnapshotData	SnapshotSelfData

PGDLLIMPORT SnapshotData	SnapshotAnyData

PGDLLIMPORT SnapshotData	CatalogSnapshotData

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ EarlyPruningEnabled

◆ InitDirtySnapshot

◆ InitNonVacuumableSnapshot

◆ InitToastSnapshot

◆ IsMVCCSnapshot

◆ OLD_SNAPSHOT_PADDING_ENTRIES

◆ OLD_SNAPSHOT_TIME_MAP_ENTRIES

◆ RelationAllowsEarlyPruning

◆ SnapshotAny

◆ SnapshotSelf

Typedef Documentation

◆ GlobalVisState

Function Documentation

◆ ActiveSnapshotSet()

◆ AtEOXact_Snapshot()

◆ AtSubAbort_Snapshot()

◆ AtSubCommit_Snapshot()

◆ DeleteAllExportedSnapshotFiles()

◆ EstimateSnapshotSpace()

◆ ExportSnapshot()

◆ GetActiveSnapshot()

◆ GetCatalogSnapshot()

◆ GetLatestSnapshot()

◆ GetNonHistoricCatalogSnapshot()

◆ GetOldestSnapshot()

◆ GetOldSnapshotThresholdTimestamp()

◆ GetSnapshotCurrentTimestamp()

◆ GetTransactionSnapshot()

◆ GlobalVisCheckRemovableFullXid()

◆ GlobalVisCheckRemovableXid()

◆ GlobalVisTestFor()

◆ GlobalVisTestIsRemovableFullXid()

◆ GlobalVisTestIsRemovableXid()

◆ GlobalVisTestNonRemovableFullHorizon()

◆ GlobalVisTestNonRemovableHorizon()

◆ HaveRegisteredOrActiveSnapshot()

◆ HistoricSnapshotActive()

◆ HistoricSnapshotGetTupleCids()

◆ ImportSnapshot()

◆ InvalidateCatalogSnapshot()

◆ InvalidateCatalogSnapshotConditionally()

◆ MaintainOldSnapshotTimeMapping()

◆ OldSnapshotThresholdActive()

◆ PopActiveSnapshot()

◆ PushActiveSnapshot()

◆ PushActiveSnapshotWithLevel()

◆ PushCopiedSnapshot()

◆ RegisterSnapshot()

◆ RegisterSnapshotOnOwner()

◆ RestoreSnapshot()

◆ RestoreTransactionSnapshot()

◆ SerializeSnapshot()

◆ SetOldSnapshotThresholdTimestamp()

◆ SetupHistoricSnapshot()

◆ SnapMgrInit()

◆ SnapMgrShmemSize()

◆ SnapshotSetCommandId()

◆ SnapshotTooOldMagicForTest()

◆ TeardownHistoricSnapshot()

◆ ThereAreNoPriorRegisteredSnapshots()

◆ TransactionIdLimitedForOldSnapshots()

◆ UnregisterSnapshot()

◆ UnregisterSnapshotFromOwner()

◆ UpdateActiveSnapshotCommandId()

◆ WaitForOlderSnapshots()

◆ XactHasExportedSnapshots()

◆ XidInMVCCSnapshot()

Variable Documentation

◆ CatalogSnapshotData

◆ FirstSnapshotSet

◆ old_snapshot_threshold

◆ RecentXmin

◆ SnapshotAnyData

◆ SnapshotSelfData

◆ TransactionXmin