snapshot.h File Reference

#include "lib/pairingheap.h"

Include dependency graph for snapshot.h:

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

Go to the source code of this file.

Data Structures
struct	SnapshotData

Macros
#define	InvalidSnapshot   ((Snapshot) NULL)

Typedefs
typedef enum SnapshotType	SnapshotType
typedef struct SnapshotData *	Snapshot
typedef struct SnapshotData	SnapshotData

Enumerations
enum	SnapshotType {   SNAPSHOT_MVCC = 0 , SNAPSHOT_SELF , SNAPSHOT_ANY , SNAPSHOT_TOAST ,   SNAPSHOT_DIRTY , SNAPSHOT_HISTORIC_MVCC , SNAPSHOT_NON_VACUUMABLE }

Macro Definition Documentation

InvalidSnapshot

#define InvalidSnapshot   ((Snapshot) NULL)

Definition at line 119 of file snapshot.h.

Typedef Documentation

Snapshot

typedef struct SnapshotData* Snapshot

Definition at line 117 of file snapshot.h.

SnapshotData

typedef struct SnapshotData SnapshotData

SnapshotType

typedef enum SnapshotType SnapshotType

Enumeration Type Documentation

SnapshotType

enum SnapshotType

Enumerator
SNAPSHOT_MVCC
SNAPSHOT_SELF
SNAPSHOT_ANY
SNAPSHOT_TOAST
SNAPSHOT_DIRTY
SNAPSHOT_HISTORIC_MVCC
SNAPSHOT_NON_VACUUMABLE

Definition at line 31 of file snapshot.h.

{
    /*-------------------------------------------------------------------------
     * A tuple is visible iff the tuple is valid for the given MVCC snapshot.
     *
     * Here, we consider the effects of:
     * - all transactions committed as of the time of the given snapshot
     * - previous commands of this transaction
     *
     * Does _not_ include:
     * - transactions shown as in-progress by the snapshot
     * - transactions started after the snapshot was taken
     * - changes made by the current command
     * -------------------------------------------------------------------------
     */
    SNAPSHOT_MVCC = 0,
 
    /*-------------------------------------------------------------------------
     * A tuple is visible iff the tuple is valid "for itself".
     *
     * Here, we consider the effects of:
     * - all committed transactions (as of the current instant)
     * - previous commands of this transaction
     * - changes made by the current command
     *
     * Does _not_ include:
     * - in-progress transactions (as of the current instant)
     * -------------------------------------------------------------------------
     */
    SNAPSHOT_SELF,
 
    /*
     * Any tuple is visible.
     */
    SNAPSHOT_ANY,
 
    /*
     * A tuple is visible iff the tuple is valid as a TOAST row.
     */
    SNAPSHOT_TOAST,
 
    /*-------------------------------------------------------------------------
     * A tuple is visible iff the tuple is valid including effects of open
     * transactions.
     *
     * Here, we consider the effects of:
     * - all committed and in-progress transactions (as of the current instant)
     * - previous commands of this transaction
     * - changes made by the current command
     *
     * This is essentially like SNAPSHOT_SELF as far as effects of the current
     * transaction and committed/aborted xacts are concerned.  However, it
     * also includes the effects of other xacts still in progress.
     *
     * A special hack is that when a snapshot of this type is used to
     * determine tuple visibility, the passed-in snapshot struct is used as an
     * output argument to return the xids of concurrent xacts that affected
     * the tuple.  snapshot->xmin is set to the tuple's xmin if that is
     * another transaction that's still in progress; or to
     * InvalidTransactionId if the tuple's xmin is committed good, committed
     * dead, or my own xact.  Similarly for snapshot->xmax and the tuple's
     * xmax.  If the tuple was inserted speculatively, meaning that the
     * inserter might still back down on the insertion without aborting the
     * whole transaction, the associated token is also returned in
     * snapshot->speculativeToken.  See also InitDirtySnapshot().
     * -------------------------------------------------------------------------
     */
    SNAPSHOT_DIRTY,
 
    /*
     * A tuple is visible iff it follows the rules of SNAPSHOT_MVCC, but
     * supports being called in timetravel context (for decoding catalog
     * contents in the context of logical decoding).
     */
    SNAPSHOT_HISTORIC_MVCC,
 
    /*
     * A tuple is visible iff the tuple might be visible to some transaction;
     * false if it's surely dead to everyone, i.e., vacuumable.
     *
     * For visibility checks snapshot->min must have been set up with the xmin
     * horizon to use.
     */
    SNAPSHOT_NON_VACUUMABLE,
} SnapshotType;