snapmgr.h File Reference

#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:

Go to the source code of this file.

Macros
#define	SnapshotSelf   (&SnapshotSelfData)
#define	SnapshotAny   (&SnapshotAnyData)
#define	InitDirtySnapshot(snapshotdata)    ((snapshotdata).snapshot_type = SNAPSHOT_DIRTY)
#define	InitNonVacuumableSnapshot(snapshotdata, vistestp)
#define	IsMVCCSnapshot(snapshot)
#define	IsHistoricMVCCSnapshot(snapshot)    ((snapshot)->snapshot_type == SNAPSHOT_HISTORIC_MVCC)

Typedefs
typedef struct GlobalVisState	GlobalVisState

Functions
Snapshot	GetTransactionSnapshot (void)
Snapshot	GetLatestSnapshot (void)
void	SnapshotSetCommandId (CommandId curcid)
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)
char *	ExportSnapshot (Snapshot snapshot)
GlobalVisState *	GlobalVisTestFor (Relation rel)
bool	GlobalVisTestIsRemovableXid (GlobalVisState *state, TransactionId xid)
bool	GlobalVisTestIsRemovableFullXid (GlobalVisState *state, FullTransactionId fxid)
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, struct PGPROC *source_pgproc)

Variables
PGDLLIMPORT bool	FirstSnapshotSet
PGDLLIMPORT TransactionId	TransactionXmin
PGDLLIMPORT TransactionId	RecentXmin
PGDLLIMPORT SnapshotData	SnapshotSelfData
PGDLLIMPORT SnapshotData	SnapshotAnyData
PGDLLIMPORT SnapshotData	SnapshotToastData

Macro Definition Documentation

InitDirtySnapshot

#define InitDirtySnapshot

(

snapshotdata

)

((snapshotdata).snapshot_type = SNAPSHOT_DIRTY)

Definition at line 42 of file snapmgr.h.

InitNonVacuumableSnapshot

#define InitNonVacuumableSnapshot	(		snapshotdata,
			vistestp
	)

Value:

    ((snapshotdata).snapshot_type = SNAPSHOT_NON_VACUUMABLE, \
     (snapshotdata).vistest = (vistestp))

Definition at line 50 of file snapmgr.h.

IsHistoricMVCCSnapshot

#define IsHistoricMVCCSnapshot

(

snapshot

)

((snapshot)->snapshot_type == SNAPSHOT_HISTORIC_MVCC)

Definition at line 59 of file snapmgr.h.

IsMVCCSnapshot

#define IsMVCCSnapshot

(

snapshot

)

Value:

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

Definition at line 55 of file snapmgr.h.

SnapshotAny

#define SnapshotAny   (&SnapshotAnyData)

Definition at line 33 of file snapmgr.h.

SnapshotSelf

#define SnapshotSelf   (&SnapshotSelfData)

Definition at line 32 of file snapmgr.h.

Typedef Documentation

GlobalVisState

typedef struct GlobalVisState GlobalVisState

Definition at line 101 of file snapmgr.h.

Function Documentation

ActiveSnapshotSet()

bool ActiveSnapshotSet ( void  )

extern

Definition at line 812 of file snapmgr.c.

{
    return ActiveSnapshot != NULL;
}

References ActiveSnapshot, and fb().

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

AtEOXact_Snapshot()

void AtEOXact_Snapshot ( bool  isCommit, bool  resetXmin  )

extern

Definition at line 1016 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;
    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, fb(), FirstSnapshotSet, FirstXactSnapshot, InvalidateCatalogSnapshot(), lfirst, MyProc, NIL, pairingheap_is_empty, pairingheap_remove(), pairingheap_reset, SnapshotData::ph_node, SnapshotData::regd_count, RegisteredSnapshots, SecondarySnapshot, SnapshotResetXmin(), WARNING, and PGPROC::xmin.

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

AtSubAbort_Snapshot()

void AtSubAbort_Snapshot ( int  level )

extern

Definition at line 982 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;
    }
 
    SnapshotResetXmin();
}

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

Referenced by AbortSubTransaction().

AtSubCommit_Snapshot()

void AtSubCommit_Snapshot ( int  level )

extern

Definition at line 961 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, ActiveSnapshotElt::as_next, and fb().

Referenced by CommitSubTransaction().

DeleteAllExportedSnapshotFiles()

void DeleteAllExportedSnapshotFiles ( void  )

extern

Definition at line 1587 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, ereport, errcode_for_file_access(), errmsg(), fb(), FreeDir(), LOG, MAXPGPATH, ReadDirExtended(), SNAPSHOT_EXPORT_DIR, and snprintf.

Referenced by StartupXLOG().

EstimateSnapshotSpace()

Size EstimateSnapshotSpace ( Snapshot  snapshot )

extern

Definition at line 1712 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 index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeParallelDSM(), and table_parallelscan_estimate().

ExportSnapshot()

char * ExportSnapshot ( Snapshot  snapshot )

extern

Definition at line 1115 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->vxid.procNumber, MyProc->vxid.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 = palloc_object(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->vxid.procNumber, MyProc->vxid.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(), buf, CopySnapshot(), ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, exportedSnapshots, fb(), FreeFile(), GetMaxSnapshotSubxidCount(), GetTopTransactionIdIfAny(), i, initStringInfo(), IsSubTransaction(), lappend(), list_length(), PGPROC::lxid, MAXPGPATH, MemoryContextSwitchTo(), MyDatabaseId, MyProc, MyProcPid, pairingheap_add(), palloc_object, PG_BINARY_W, SnapshotData::ph_node, PGPROC::procNumber, pstrdup(), SnapshotData::regd_count, RegisteredSnapshots, SNAPSHOT_EXPORT_DIR, snprintf, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TopTransactionContext, TransactionIdIsValid, TransactionIdPrecedes(), PGPROC::vxid, xactGetCommittedChildren(), XactIsoLevel, XactReadOnly, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by pg_export_snapshot(), and SnapBuildExportSnapshot().

GetActiveSnapshot()

Snapshot GetActiveSnapshot ( void  )

extern

Definition at line 800 of file snapmgr.c.

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

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

Referenced by _SPI_execute_plan(), ATExecDetachPartitionFinalize(), BeginCopyTo(), CopyRelationTo(), EnsurePortalSnapshotExists(), ExecCreateTableAs(), ExecInitParallelPlan(), ExecParallelGetQueryDesc(), execute_sql_string(), ExecuteQuery(), ExplainOnePlan(), find_inheritance_children_extended(), FindConflictTuple(), has_lo_priv_byid(), InitializeParallelDSM(), inv_open(), PerformCursorOpen(), pg_current_snapshot(), pg_export_snapshot(), pgrowlocks(), PortalRunUtility(), PortalStart(), postquel_start(), ProcessQuery(), refresh_matview_datafill(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RelationGetPartitionDesc(), spgvacuumscan(), SPI_cursor_open_internal(), standard_ExecutorRun(), and standard_ExecutorStart().

GetCatalogSnapshot()

Snapshot GetCatalogSnapshot ( Oid  relid )

extern

Definition at line 385 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  )

extern

Definition at line 354 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 asyncQueueReadAllNotifications(), ATRewriteTable(), check_default_partition_contents(), currtid_internal(), FindConflictTuple(), IndexCheckExclusion(), MergePartitionsMoveRows(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RI_Initial_Check(), RI_PartitionRemove_Check(), ri_PerformCheck(), ScanSourceDatabasePgClass(), SplitPartitionMoveRows(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

GetNonHistoricCatalogSnapshot()

Snapshot GetNonHistoricCatalogSnapshot ( Oid  relid )

extern

Definition at line 407 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, fb(), GetSnapshotData(), InvalidateCatalogSnapshot(), pairingheap_add(), SnapshotData::ph_node, RegisteredSnapshots, RelationHasSysCache(), and RelationInvalidatesSnapshotsOnly().

Referenced by GetCatalogSnapshot(), and ScanPgRelation().

GetTransactionSnapshot()

Snapshot GetTransactionSnapshot ( void  )

extern

Definition at line 272 of file snapmgr.c.

{
    /*
     * Return historic snapshot if doing logical decoding.
     *
     * Historic snapshots are only usable for catalog access, not for
     * general-purpose queries.  The caller is responsible for ensuring that
     * the snapshot is used correctly! (PostgreSQL code never calls this
     * during logical decoding, but extensions can do it.)
     */
    if (HistoricSnapshotActive())
    {
        /*
         * 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().
         */
        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, fb(), 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 _brin_begin_parallel(), _bt_begin_parallel(), _gin_begin_parallel(), _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), ATExecDetachPartition(), begin_replication_step(), bt_check_every_level(), BuildCachedPlan(), CheckTargetForConflictsIn(), clear_subscription_skip_lsn(), cluster_multiple_rels(), DefineIndex(), detachPartitionTable(), DisableSubscriptionAndExit(), do_autovacuum(), EnsurePortalSnapshotExists(), EventTriggerOnLogin(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), ExecuteCallStmt(), fmgr_sql(), GetLatestSnapshot(), HandleFunctionRequest(), heapam_index_build_range_scan(), index_drop(), initialize_worker_spi(), InitializeParallelDSM(), LogicalRepSyncTableStart(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), PortalStart(), PreCommit_on_commit_actions(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), ri_PerformCheck(), run_apply_worker(), SPI_cursor_open_internal(), update_retention_status(), vacuum(), vacuum_rel(), verify_heapam(), worker_spi_main(), and XidIsConcurrent().

GlobalVisCheckRemovableFullXid()

bool GlobalVisCheckRemovableFullXid ( Relation  rel, FullTransactionId  fxid  )

extern

Definition at line 4265 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  )

extern

Definition at line 4279 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 )

extern

Definition at line 4086 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, fb(), 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  )

extern

Definition at line 4201 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  )

extern

Definition at line 4243 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().

HaveRegisteredOrActiveSnapshot()

bool HaveRegisteredOrActiveSnapshot ( void  )

extern

Definition at line 1644 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, fb(), pairingheap_is_empty, pairingheap_is_singular, and RegisteredSnapshots.

Referenced by AssertHasSnapshotForToast(), ExecWaitStmt(), get_toast_snapshot(), and SnapBuildInitialSnapshot().

HistoricSnapshotActive()

bool HistoricSnapshotActive ( void  )

extern

Definition at line 1692 of file snapmgr.c.

{
    return HistoricSnapshot != NULL;
}

References fb(), and HistoricSnapshot.

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

HistoricSnapshotGetTupleCids()

struct HTAB * HistoricSnapshotGetTupleCids ( void  )

extern

Definition at line 1698 of file snapmgr.c.

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

References Assert, HistoricSnapshotActive(), and tuplecid_data.

Referenced by HeapTupleSatisfiesHistoricMVCC().

ImportSnapshot()

void ImportSnapshot ( const char *  idstr )

extern

Definition at line 1387 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)
    {
        /*
         * If file is missing while identifier has a correct format, avoid
         * system errors.
         */
        if (errno == ENOENT)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("snapshot \"%s\" does not exist", idstr)));
        else
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not open file \"%s\" for reading: %m",
                            path)));
    }
 
    /* 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(), errcode_for_file_access(), errmsg(), ERROR, fb(), 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, 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  )

extern

Definition at line 455 of file snapmgr.c.

{
    if (CatalogSnapshot)
    {
        pairingheap_remove(&RegisteredSnapshots, &CatalogSnapshot->ph_node);
        CatalogSnapshot = NULL;
        SnapshotResetXmin();
        INJECTION_POINT("invalidate-catalog-snapshot-end", NULL);
    }
}

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

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

InvalidateCatalogSnapshotConditionally()

void InvalidateCatalogSnapshotConditionally ( void  )

extern

Definition at line 477 of file snapmgr.c.

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

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

Referenced by PostgresMain().

PopActiveSnapshot()

void PopActiveSnapshot ( void  )

extern

Definition at line 775 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;
 
    SnapshotResetXmin();
}

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

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

PushActiveSnapshot()

void PushActiveSnapshot ( Snapshot  snapshot )

extern

Definition at line 682 of file snapmgr.c.

{
    PushActiveSnapshotWithLevel(snapshot, GetCurrentTransactionNestLevel());
}

References GetCurrentTransactionNestLevel(), and PushActiveSnapshotWithLevel().

Referenced by _SPI_execute_plan(), AfterTriggerFireDeferred(), AfterTriggerSetState(), ATExecDetachPartition(), begin_replication_step(), BuildCachedPlan(), clear_subscription_skip_lsn(), cluster_multiple_rels(), DefineIndex(), detachPartitionTable(), DisableSubscriptionAndExit(), do_autovacuum(), DoPortalRewind(), EventTriggerOnLogin(), exec_bind_message(), exec_eval_simple_expr(), exec_parse_message(), exec_simple_query(), execute_sql_string(), ExecuteCallStmt(), FindConflictTuple(), fmgr_sql(), HandleFunctionRequest(), index_drop(), initialize_worker_spi(), LogicalRepSyncTableStart(), ParallelWorkerMain(), PersistHoldablePortal(), PortalRunSelect(), PortalStart(), PreCommit_on_commit_actions(), PushCopiedSnapshot(), ReindexMultipleInternal(), ReindexRelationConcurrently(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), RemoveTempRelationsCallback(), RevalidateCachedQuery(), run_apply_worker(), ShutdownSQLFunction(), update_retention_status(), vacuum(), vacuum_rel(), and worker_spi_main().

PushActiveSnapshotWithLevel()

void PushActiveSnapshotWithLevel ( Snapshot  snapshot, int  snap_level  )

extern

Definition at line 696 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;
}

References ActiveSnapshot, ActiveSnapshotElt::as_level, Assert, SnapshotData::copied, CopySnapshot(), CurrentSnapshot, fb(), InvalidSnapshot, MemoryContextAlloc(), SecondarySnapshot, and TopTransactionContext.

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

PushCopiedSnapshot()

void PushCopiedSnapshot ( Snapshot  snapshot )

extern

Definition at line 732 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 )

extern

Definition at line 824 of file snapmgr.c.

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

References CurrentResourceOwner, InvalidSnapshot, and RegisterSnapshotOnOwner().

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), _gin_begin_parallel(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), CreateQueryDesc(), currtid_internal(), DefineIndex(), heapam_index_build_range_scan(), index_beginscan_parallel(), IndexCheckExclusion(), MergePartitionsMoveRows(), pg_get_constraintdef_worker(), PortalRunMulti(), PortalRunUtility(), process_settings(), ReindexRelationConcurrently(), ScanPgRelation(), ScanSourceDatabasePgClass(), SplitPartitionMoveRows(), standard_ExecutorStart(), systable_beginscan(), systable_beginscan_ordered(), systable_recheck_tuple(), table_beginscan_catalog(), table_beginscan_parallel(), table_beginscan_parallel_tidrange(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

RegisterSnapshotOnOwner()

Snapshot RegisterSnapshotOnOwner ( Snapshot  snapshot, ResourceOwner  owner  )

extern

Definition at line 837 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 */
    ResourceOwnerEnlarge(owner);
    snap->regd_count++;
    ResourceOwnerRememberSnapshot(owner, snap);
 
    if (snap->regd_count == 1)
        pairingheap_add(&RegisteredSnapshots, &snap->ph_node);
 
    return snap;
}

References SnapshotData::copied, CopySnapshot(), fb(), InvalidSnapshot, pairingheap_add(), RegisteredSnapshots, ResourceOwnerEnlarge(), and ResourceOwnerRememberSnapshot().

Referenced by be_lo_open(), and RegisterSnapshot().

RestoreSnapshot()

Snapshot RestoreSnapshot ( char *  start_address )

extern

Definition at line 1793 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->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;
}

References SnapshotData::active_count, SnapshotData::copied, SnapshotData::curcid, fb(), MemoryContextAlloc(), SnapshotData::regd_count, SNAPSHOT_MVCC, SnapshotData::snapshot_type, SnapshotData::snapXactCompletionCount, SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, TopTransactionContext, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

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

RestoreTransactionSnapshot()

void RestoreTransactionSnapshot ( Snapshot  snapshot, struct PGPROC *  source_pgproc  )

extern

Definition at line 1853 of file snapmgr.c.

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

References fb(), InvalidPid, and SetTransactionSnapshot().

Referenced by CreateReplicationSlot(), and ParallelWorkerMain().

SerializeSnapshot()

void SerializeSnapshot ( Snapshot  snapshot, char *  start_address  )

extern

Definition at line 1736 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;
 
    /*
     * 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));
    }
}

References Assert, SnapshotData::curcid, fb(), SnapshotData::suboverflowed, SnapshotData::subxcnt, SnapshotData::subxip, SnapshotData::takenDuringRecovery, SnapshotData::xcnt, SnapshotData::xip, SnapshotData::xmax, and SnapshotData::xmin.

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

SetupHistoricSnapshot()

void SetupHistoricSnapshot ( Snapshot  historic_snapshot, struct HTAB *  tuplecids  )

extern

Definition at line 1669 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, fb(), HistoricSnapshot, and tuplecid_data.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

SnapshotSetCommandId()

void SnapshotSetCommandId ( CommandId  curcid )

extern

Definition at line 490 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().

TeardownHistoricSnapshot()

void TeardownHistoricSnapshot ( bool  is_error )

extern

Definition at line 1685 of file snapmgr.c.

{
    HistoricSnapshot = NULL;
    tuplecid_data = NULL;
}

References fb(), HistoricSnapshot, and tuplecid_data.

Referenced by ReorderBufferProcessTXN(), and ReorderBufferQueueMessage().

ThereAreNoPriorRegisteredSnapshots()

bool ThereAreNoPriorRegisteredSnapshots ( void  )

extern

Definition at line 1626 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().

UnregisterSnapshot()

void UnregisterSnapshot ( Snapshot  snapshot )

extern

Definition at line 866 of file snapmgr.c.

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

References CurrentResourceOwner, fb(), and UnregisterSnapshotFromOwner().

Referenced by _brin_begin_parallel(), _brin_end_parallel(), _bt_begin_parallel(), _bt_end_parallel(), _gin_begin_parallel(), _gin_end_parallel(), asyncQueueReadAllNotifications(), ATRewriteTable(), bt_check_every_level(), check_default_partition_contents(), currtid_internal(), DefineIndex(), FreeQueryDesc(), heap_endscan(), heapam_index_build_range_scan(), index_endscan(), IndexCheckExclusion(), MergePartitionsMoveRows(), pg_get_constraintdef_worker(), process_settings(), ReindexRelationConcurrently(), ScanPgRelation(), ScanSourceDatabasePgClass(), SplitPartitionMoveRows(), standard_ExecutorEnd(), systable_endscan(), systable_endscan_ordered(), systable_recheck_tuple(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

UnregisterSnapshotFromOwner()

void UnregisterSnapshotFromOwner ( Snapshot  snapshot, ResourceOwner  owner  )

extern

Definition at line 879 of file snapmgr.c.

{
    if (snapshot == NULL)
        return;
 
    ResourceOwnerForgetSnapshot(owner, snapshot);
    UnregisterSnapshotNoOwner(snapshot);
}

References fb(), ResourceOwnerForgetSnapshot(), and UnregisterSnapshotNoOwner().

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

UpdateActiveSnapshotCommandId()

void UpdateActiveSnapshotCommandId ( void  )

extern

Definition at line 744 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, fb(), 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  )

extern

Definition at line 435 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 = ProcNumberGetProc(old_snapshots[i].procNumber);
 
                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 fb(), GetCurrentVirtualXIDs(), i, j, pfree(), pgstat_progress_update_param(), PROC_IN_SAFE_IC, PROC_IN_VACUUM, PROC_IS_AUTOVACUUM, ProcNumberGetProc(), 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  )

extern

Definition at line 1574 of file snapmgr.c.

{
    return (exportedSnapshots != NIL);
}

References exportedSnapshots, and NIL.

Referenced by PrepareTransaction().

XidInMVCCSnapshot()

bool XidInMVCCSnapshot ( TransactionId  xid, Snapshot  snapshot  )

extern

Definition at line 1869 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

FirstSnapshotSet

PGDLLIMPORT bool FirstSnapshotSet

extern

Definition at line 193 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().

RecentXmin

PGDLLIMPORT TransactionId RecentXmin

extern

Definition at line 160 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(), and TransactionIdIsInProgress().

SnapshotAnyData

PGDLLIMPORT SnapshotData SnapshotAnyData

extern

Definition at line 145 of file snapmgr.c.

{SNAPSHOT_ANY};

SnapshotSelfData

PGDLLIMPORT SnapshotData SnapshotSelfData

extern

Definition at line 144 of file snapmgr.c.

{SNAPSHOT_SELF};

SnapshotToastData

PGDLLIMPORT SnapshotData SnapshotToastData

extern

Definition at line 146 of file snapmgr.c.

{SNAPSHOT_TOAST};

Referenced by get_toast_snapshot().

TransactionXmin

PGDLLIMPORT TransactionId TransactionXmin

extern

Definition at line 159 of file snapmgr.c.

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