tuptable.h File Reference

#include "access/htup.h"
#include "access/sysattr.h"
#include "access/tupdesc.h"
#include "storage/buf.h"

Include dependency graph for tuptable.h:

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

Go to the source code of this file.

Data Structures
struct	TupleTableSlot
struct	TupleTableSlotOps
struct	VirtualTupleTableSlot
struct	HeapTupleTableSlot
struct	BufferHeapTupleTableSlot
struct	MinimalTupleTableSlot

Macros
#define	TTS_FLAG_EMPTY   (1 << 1)
#define	TTS_EMPTY(slot)   (((slot)->tts_flags & TTS_FLAG_EMPTY) != 0)
#define	TTS_FLAG_SHOULDFREE   (1 << 2)
#define	TTS_SHOULDFREE(slot)   (((slot)->tts_flags & TTS_FLAG_SHOULDFREE) != 0)
#define	TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS   (1 << 3)
#define	TTS_OBEYS_NOT_NULL_CONSTRAINTS(slot)    (((slot)->tts_flags & TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS) != 0)
#define	TTS_FLAG_FIXED   (1 << 4)
#define	TTS_FIXED(slot)   (((slot)->tts_flags & TTS_FLAG_FIXED) != 0)
#define	TTS_FLAGS_TRANSIENT   (TTS_FLAG_EMPTY|TTS_FLAG_SHOULDFREE)
#define	FIELDNO_TUPLETABLESLOT_FLAGS   1
#define	FIELDNO_TUPLETABLESLOT_NVALID   2
#define	FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4
#define	FIELDNO_TUPLETABLESLOT_VALUES   5
#define	FIELDNO_TUPLETABLESLOT_ISNULL   6
#define	TTS_IS_VIRTUAL(slot)   ((slot)->tts_ops == &TTSOpsVirtual)
#define	TTS_IS_HEAPTUPLE(slot)   ((slot)->tts_ops == &TTSOpsHeapTuple)
#define	TTS_IS_MINIMALTUPLE(slot)   ((slot)->tts_ops == &TTSOpsMinimalTuple)
#define	TTS_IS_BUFFERTUPLE(slot)   ((slot)->tts_ops == &TTSOpsBufferHeapTuple)
#define	FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1
#define	FIELDNO_HEAPTUPLETABLESLOT_OFF   2
#define	FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1
#define	FIELDNO_MINIMALTUPLETABLESLOT_OFF   4
#define	TupIsNull(slot)    ((slot) == NULL || TTS_EMPTY(slot))

Typedefs
typedef struct TupleTableSlotOps	TupleTableSlotOps
typedef struct TupleTableSlot	TupleTableSlot
typedef struct VirtualTupleTableSlot	VirtualTupleTableSlot
typedef struct HeapTupleTableSlot	HeapTupleTableSlot
typedef struct BufferHeapTupleTableSlot	BufferHeapTupleTableSlot
typedef struct MinimalTupleTableSlot	MinimalTupleTableSlot

Functions
TupleTableSlot *	MakeTupleTableSlot (TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops, uint16 flags)
TupleTableSlot *	ExecAllocTableSlot (List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops, uint16 flags)
void	ExecResetTupleTable (List *tupleTable, bool shouldFree)
TupleTableSlot *	MakeSingleTupleTableSlot (TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
void	ExecDropSingleTupleTableSlot (TupleTableSlot *slot)
void	ExecSetSlotDescriptor (TupleTableSlot *slot, TupleDesc tupdesc)
TupleTableSlot *	ExecStoreHeapTuple (HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
void	ExecForceStoreHeapTuple (HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
TupleTableSlot *	ExecStoreBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
TupleTableSlot *	ExecStorePinnedBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
TupleTableSlot *	ExecStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
void	ExecForceStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
TupleTableSlot *	ExecStoreVirtualTuple (TupleTableSlot *slot)
TupleTableSlot *	ExecStoreAllNullTuple (TupleTableSlot *slot)
void	ExecStoreHeapTupleDatum (Datum data, TupleTableSlot *slot)
HeapTuple	ExecFetchSlotHeapTuple (TupleTableSlot *slot, bool materialize, bool *shouldFree)
MinimalTuple	ExecFetchSlotMinimalTuple (TupleTableSlot *slot, bool *shouldFree)
Datum	ExecFetchSlotHeapTupleDatum (TupleTableSlot *slot)
void	slot_getmissingattrs (TupleTableSlot *slot, int startAttNum, int lastAttNum)
void	slot_getsomeattrs_int (TupleTableSlot *slot, int attnum)
static void	slot_getsomeattrs (TupleTableSlot *slot, int attnum)
static void	slot_getallattrs (TupleTableSlot *slot)
static bool	slot_attisnull (TupleTableSlot *slot, int attnum)
static Datum	slot_getattr (TupleTableSlot *slot, int attnum, bool *isnull)
static Datum	slot_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
static bool	slot_is_current_xact_tuple (TupleTableSlot *slot)
static TupleTableSlot *	ExecClearTuple (TupleTableSlot *slot)
static void	ExecMaterializeSlot (TupleTableSlot *slot)
static HeapTuple	ExecCopySlotHeapTuple (TupleTableSlot *slot)
static MinimalTuple	ExecCopySlotMinimalTuple (TupleTableSlot *slot)
static MinimalTuple	ExecCopySlotMinimalTupleExtra (TupleTableSlot *slot, Size extra)
static TupleTableSlot *	ExecCopySlot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)

Variables
PGDLLIMPORT const TupleTableSlotOps	TTSOpsVirtual
PGDLLIMPORT const TupleTableSlotOps	TTSOpsHeapTuple
PGDLLIMPORT const TupleTableSlotOps	TTSOpsMinimalTuple
PGDLLIMPORT const TupleTableSlotOps	TTSOpsBufferHeapTuple

Macro Definition Documentation

FIELDNO_HEAPTUPLETABLESLOT_OFF

#define FIELDNO_HEAPTUPLETABLESLOT_OFF   2

Definition at line 280 of file tuptable.h.

FIELDNO_HEAPTUPLETABLESLOT_TUPLE

#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1

Definition at line 278 of file tuptable.h.

FIELDNO_MINIMALTUPLETABLESLOT_OFF

#define FIELDNO_MINIMALTUPLETABLESLOT_OFF   4

Definition at line 318 of file tuptable.h.

FIELDNO_MINIMALTUPLETABLESLOT_TUPLE

#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1

Definition at line 314 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_FLAGS

#define FIELDNO_TUPLETABLESLOT_FLAGS   1

Definition at line 123 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_ISNULL

#define FIELDNO_TUPLETABLESLOT_ISNULL   6

Definition at line 132 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_NVALID

#define FIELDNO_TUPLETABLESLOT_NVALID   2

Definition at line 125 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR

#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4

Definition at line 128 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_VALUES

#define FIELDNO_TUPLETABLESLOT_VALUES   5

Definition at line 130 of file tuptable.h.

TTS_EMPTY

#define TTS_EMPTY

(

slot

)

(((slot)->tts_flags & TTS_FLAG_EMPTY) != 0)

Definition at line 92 of file tuptable.h.

TTS_FIXED

#define TTS_FIXED

(

slot

)

(((slot)->tts_flags & TTS_FLAG_FIXED) != 0)

Definition at line 108 of file tuptable.h.

TTS_FLAG_EMPTY

#define TTS_FLAG_EMPTY   (1 << 1)

Definition at line 91 of file tuptable.h.

TTS_FLAG_FIXED

#define TTS_FLAG_FIXED   (1 << 4)

Definition at line 107 of file tuptable.h.

TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS

#define TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS   (1 << 3)

Definition at line 102 of file tuptable.h.

TTS_FLAG_SHOULDFREE

#define TTS_FLAG_SHOULDFREE   (1 << 2)

Definition at line 95 of file tuptable.h.

TTS_FLAGS_TRANSIENT

#define TTS_FLAGS_TRANSIENT   (TTS_FLAG_EMPTY|TTS_FLAG_SHOULDFREE)

Definition at line 114 of file tuptable.h.

TTS_IS_BUFFERTUPLE

#define TTS_IS_BUFFERTUPLE

(

slot

)

((slot)->tts_ops == &TTSOpsBufferHeapTuple)

Definition at line 256 of file tuptable.h.

TTS_IS_HEAPTUPLE

#define TTS_IS_HEAPTUPLE

(

slot

)

((slot)->tts_ops == &TTSOpsHeapTuple)

Definition at line 254 of file tuptable.h.

TTS_IS_MINIMALTUPLE

#define TTS_IS_MINIMALTUPLE

(

slot

)

((slot)->tts_ops == &TTSOpsMinimalTuple)

Definition at line 255 of file tuptable.h.

TTS_IS_VIRTUAL

#define TTS_IS_VIRTUAL

(

slot

)

((slot)->tts_ops == &TTSOpsVirtual)

Definition at line 253 of file tuptable.h.

TTS_OBEYS_NOT_NULL_CONSTRAINTS

#define TTS_OBEYS_NOT_NULL_CONSTRAINTS

(

slot

)

(((slot)->tts_flags & TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS) != 0)

Definition at line 103 of file tuptable.h.

{
    NodeTag     type;
#define FIELDNO_TUPLETABLESLOT_FLAGS 1
    uint16      tts_flags;      /* Boolean states */
#define FIELDNO_TUPLETABLESLOT_NVALID 2
    AttrNumber  tts_nvalid;     /* # of valid values in tts_values */
    const TupleTableSlotOps *const tts_ops; /* implementation of slot */
#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR 4
    TupleDesc   tts_tupleDescriptor;    /* slot's tuple descriptor */
#define FIELDNO_TUPLETABLESLOT_VALUES 5
    Datum      *tts_values;     /* current per-attribute values */
#define FIELDNO_TUPLETABLESLOT_ISNULL 6
    bool       *tts_isnull;     /* current per-attribute isnull flags.  Array
                                 * size must always be rounded up to the next
                                 * multiple of 8 elements. */
    int         tts_first_nonguaranteed;    /* The value from the TupleDesc's
                                             * firstNonGuaranteedAttr, or 0
                                             * when tts_flags does not contain
                                             * TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS */
 
    MemoryContext tts_mcxt;     /* slot itself is in this context */
    ItemPointerData tts_tid;    /* stored tuple's tid */
    Oid         tts_tableOid;   /* table oid of tuple */
} TupleTableSlot;
 
/* routines for a TupleTableSlot implementation */
struct TupleTableSlotOps
{
    /* Minimum size of the slot */
    size_t      base_slot_size;
 
    /* Initialization. */
    void        (*init) (TupleTableSlot *slot);
 
    /* Destruction. */
    void        (*release) (TupleTableSlot *slot);
 
    /*
     * Clear the contents of the slot. Only the contents are expected to be
     * cleared and not the tuple descriptor. Typically an implementation of
     * this callback should free the memory allocated for the tuple contained
     * in the slot.
     */
    void        (*clear) (TupleTableSlot *slot);
 
    /*
     * Fill up first natts entries of tts_values and tts_isnull arrays with
     * values from the tuple contained in the slot and set the slot's
     * tts_nvalid to natts. The function may be called with an natts value
     * more than the number of attributes available in the tuple, in which
     * case the function must call slot_getmissingattrs() to populate the
     * remaining attributes.  The function must raise an ERROR if 'natts' is
     * higher than the number of attributes in the slot's TupleDesc.
     */
    void        (*getsomeattrs) (TupleTableSlot *slot, int natts);
 
    /*
     * Returns value of the given system attribute as a datum and sets isnull
     * to false, if it's not NULL. Throws an error if the slot type does not
     * support system attributes.
     */
    Datum       (*getsysattr) (TupleTableSlot *slot, int attnum, bool *isnull);
 
    /*
     * Check if the tuple is created by the current transaction. Throws an
     * error if the slot doesn't contain the storage tuple.
     */
    bool        (*is_current_xact_tuple) (TupleTableSlot *slot);
 
    /*
     * Make the contents of the slot solely depend on the slot, and not on
     * underlying resources (like another memory context, buffers, etc).
     */
    void        (*materialize) (TupleTableSlot *slot);
 
    /*
     * Copy the contents of the source slot into the destination slot's own
     * context. Invoked using callback of the destination slot.  'dstslot' and
     * 'srcslot' can be assumed to have the same number of attributes.
     */
    void        (*copyslot) (TupleTableSlot *dstslot, TupleTableSlot *srcslot);
 
    /*
     * Return a heap tuple "owned" by the slot. It is slot's responsibility to
     * free the memory consumed by the heap tuple. If the slot can not "own" a
     * heap tuple, it should not implement this callback and should set it as
     * NULL.
     */
    HeapTuple   (*get_heap_tuple) (TupleTableSlot *slot);
 
    /*
     * Return a minimal tuple "owned" by the slot. It is slot's responsibility
     * to free the memory consumed by the minimal tuple. If the slot can not
     * "own" a minimal tuple, it should not implement this callback and should
     * set it as NULL.
     */
    MinimalTuple (*get_minimal_tuple) (TupleTableSlot *slot);
 
    /*
     * Return a copy of heap tuple representing the contents of the slot. The
     * copy needs to be palloc'd in the current memory context. The slot
     * itself is expected to remain unaffected. It is *not* expected to have
     * meaningful "system columns" in the copy. The copy is not be "owned" by
     * the slot i.e. the caller has to take responsibility to free memory
     * consumed by the slot.
     */
    HeapTuple   (*copy_heap_tuple) (TupleTableSlot *slot);
 
    /*
     * Return a copy of minimal tuple representing the contents of the slot.
     * The copy needs to be palloc'd in the current memory context. The slot
     * itself is expected to remain unaffected. It is *not* expected to have
     * meaningful "system columns" in the copy. The copy is not be "owned" by
     * the slot i.e. the caller has to take responsibility to free memory
     * consumed by the slot.
     *
     * The copy has "extra" bytes (maxaligned and zeroed) available before the
     * tuple, which is useful so that some callers may store extra data along
     * with the minimal tuple without the need for an additional allocation.
     */
    MinimalTuple (*copy_minimal_tuple) (TupleTableSlot *slot, Size extra);
};
 
/*
 * Predefined TupleTableSlotOps for various types of TupleTableSlotOps. The
 * same are used to identify the type of a given slot.
 */
extern PGDLLIMPORT const TupleTableSlotOps TTSOpsVirtual;
extern PGDLLIMPORT const TupleTableSlotOps TTSOpsHeapTuple;
extern PGDLLIMPORT const TupleTableSlotOps TTSOpsMinimalTuple;
extern PGDLLIMPORT const TupleTableSlotOps TTSOpsBufferHeapTuple;
 
#define TTS_IS_VIRTUAL(slot) ((slot)->tts_ops == &TTSOpsVirtual)
#define TTS_IS_HEAPTUPLE(slot) ((slot)->tts_ops == &TTSOpsHeapTuple)
#define TTS_IS_MINIMALTUPLE(slot) ((slot)->tts_ops == &TTSOpsMinimalTuple)
#define TTS_IS_BUFFERTUPLE(slot) ((slot)->tts_ops == &TTSOpsBufferHeapTuple)
 
 
/*
 * Tuple table slot implementations.
 */
 
typedef struct VirtualTupleTableSlot
{
    pg_node_attr(abstract)
 
    TupleTableSlot base;
 
    char       *data;           /* data for materialized slots */
} VirtualTupleTableSlot;
 
typedef struct HeapTupleTableSlot
{
    pg_node_attr(abstract)
 
    TupleTableSlot base;
 
#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE 1
    HeapTuple   tuple;          /* physical tuple */
#define FIELDNO_HEAPTUPLETABLESLOT_OFF 2
    uint32      off;            /* saved state for slot_deform_heap_tuple */
    HeapTupleData tupdata;      /* optional workspace for storing tuple */
} HeapTupleTableSlot;
 
/* heap tuple residing in a buffer */
typedef struct BufferHeapTupleTableSlot
{
    pg_node_attr(abstract)
 
    HeapTupleTableSlot base;
 
    /*
     * If buffer is not InvalidBuffer, then the slot is holding a pin on the
     * indicated buffer page; drop the pin when we release the slot's
     * reference to that buffer.  (TTS_FLAG_SHOULDFREE should not be set in
     * such a case, since presumably base.tuple is pointing into the buffer.)
     */
    Buffer      buffer;         /* tuple's buffer, or InvalidBuffer */
} BufferHeapTupleTableSlot;
 
typedef struct MinimalTupleTableSlot
{
    pg_node_attr(abstract)
 
    TupleTableSlot base;
 
    /*
     * In a minimal slot tuple points at minhdr and the fields of that struct
     * are set correctly for access to the minimal tuple; in particular,
     * minhdr.t_data points MINIMAL_TUPLE_OFFSET bytes before mintuple.  This
     * allows column extraction to treat the case identically to regular
     * physical tuples.
     */
#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE 1
    HeapTuple   tuple;          /* tuple wrapper */
    MinimalTuple mintuple;      /* minimal tuple, or NULL if none */
    HeapTupleData minhdr;       /* workspace for minimal-tuple-only case */
#define FIELDNO_MINIMALTUPLETABLESLOT_OFF 4
    uint32      off;            /* saved state for slot_deform_heap_tuple */
} MinimalTupleTableSlot;
 
/*
 * TupIsNull -- is a TupleTableSlot empty?
 */
#define TupIsNull(slot) \
    ((slot) == NULL || TTS_EMPTY(slot))
 
/* in executor/execTuples.c */
extern TupleTableSlot *MakeTupleTableSlot(TupleDesc tupleDesc,
                                          const TupleTableSlotOps *tts_ops,
                                          uint16 flags);
extern TupleTableSlot *ExecAllocTableSlot(List **tupleTable, TupleDesc desc,
                                          const TupleTableSlotOps *tts_ops,
                                          uint16 flags);
extern void ExecResetTupleTable(List *tupleTable, bool shouldFree);
extern TupleTableSlot *MakeSingleTupleTableSlot(TupleDesc tupdesc,
                                                const TupleTableSlotOps *tts_ops);
extern void ExecDropSingleTupleTableSlot(TupleTableSlot *slot);
extern void ExecSetSlotDescriptor(TupleTableSlot *slot, TupleDesc tupdesc);
extern TupleTableSlot *ExecStoreHeapTuple(HeapTuple tuple,
                                          TupleTableSlot *slot,
                                          bool shouldFree);
extern void ExecForceStoreHeapTuple(HeapTuple tuple,
                                    TupleTableSlot *slot,
                                    bool shouldFree);
extern TupleTableSlot *ExecStoreBufferHeapTuple(HeapTuple tuple,
                                                TupleTableSlot *slot,
                                                Buffer buffer);
extern TupleTableSlot *ExecStorePinnedBufferHeapTuple(HeapTuple tuple,
                                                      TupleTableSlot *slot,
                                                      Buffer buffer);
extern TupleTableSlot *ExecStoreMinimalTuple(MinimalTuple mtup,
                                             TupleTableSlot *slot,
                                             bool shouldFree);
extern void ExecForceStoreMinimalTuple(MinimalTuple mtup, TupleTableSlot *slot,
                                       bool shouldFree);
extern TupleTableSlot *ExecStoreVirtualTuple(TupleTableSlot *slot);
extern TupleTableSlot *ExecStoreAllNullTuple(TupleTableSlot *slot);
extern void ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot);
extern HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree);
extern MinimalTuple ExecFetchSlotMinimalTuple(TupleTableSlot *slot,
                                              bool *shouldFree);
extern Datum ExecFetchSlotHeapTupleDatum(TupleTableSlot *slot);
extern void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum,
                                 int lastAttNum);
extern void slot_getsomeattrs_int(TupleTableSlot *slot, int attnum);
 
 
#ifndef FRONTEND
 
/*
 * This function forces the entries of the slot's Datum/isnull arrays to be
 * valid at least up through the attnum'th entry.
 */
static inline void
slot_getsomeattrs(TupleTableSlot *slot, int attnum)
{
    /* Populate slot with attributes up to 'attnum', if it's not already */
    if (slot->tts_nvalid < attnum)
        slot->tts_ops->getsomeattrs(slot, attnum);
}
 
/*
 * slot_getallattrs
 *      This function forces all the entries of the slot's Datum/isnull
 *      arrays to be valid.  The caller may then extract data directly
 *      from those arrays instead of using slot_getattr.
 */
static inline void
slot_getallattrs(TupleTableSlot *slot)
{
    slot_getsomeattrs(slot, slot->tts_tupleDescriptor->natts);
}
 
 
/*
 * slot_attisnull
 *
 * Detect whether an attribute of the slot is null, without actually fetching
 * it.
 */
static inline bool
slot_attisnull(TupleTableSlot *slot, int attnum)
{
    Assert(attnum > 0);
 
    if (attnum > slot->tts_nvalid)
        slot_getsomeattrs(slot, attnum);
 
    return slot->tts_isnull[attnum - 1];
}
 
/*
 * slot_getattr - fetch one attribute of the slot's contents.
 */
static inline Datum
slot_getattr(TupleTableSlot *slot, int attnum,
             bool *isnull)
{
    Assert(attnum > 0);
 
    if (attnum > slot->tts_nvalid)
        slot_getsomeattrs(slot, attnum);
 
    *isnull = slot->tts_isnull[attnum - 1];
 
    return slot->tts_values[attnum - 1];
}
 
/*
 * slot_getsysattr - fetch a system attribute of the slot's current tuple.
 *
 *  If the slot type does not contain system attributes, this will throw an
 *  error.  Hence before calling this function, callers should make sure that
 *  the slot type is the one that supports system attributes.
 */
static inline Datum
slot_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
{
    Assert(attnum < 0);         /* caller error */
 
    if (attnum == TableOidAttributeNumber)
    {
        *isnull = false;
        return ObjectIdGetDatum(slot->tts_tableOid);
    }
    else if (attnum == SelfItemPointerAttributeNumber)
    {
        *isnull = false;
        return PointerGetDatum(&slot->tts_tid);
    }
 
    /* Fetch the system attribute from the underlying tuple. */
    return slot->tts_ops->getsysattr(slot, attnum, isnull);
}
 
/*
 * slot_is_current_xact_tuple - check if the slot's current tuple is created
 *                              by the current transaction.
 *
 *  If the slot does not contain a storage tuple, this will throw an error.
 *  Hence before calling this function, callers should make sure that the
 *  slot type supports storage tuples and that there is currently one inside
 *  the slot.
 */
static inline bool
slot_is_current_xact_tuple(TupleTableSlot *slot)
{
    return slot->tts_ops->is_current_xact_tuple(slot);
}
 
/*
 * ExecClearTuple - clear the slot's contents
 */
static inline TupleTableSlot *
ExecClearTuple(TupleTableSlot *slot)
{
    slot->tts_ops->clear(slot);
 
    return slot;
}
 
/*
 * ExecMaterializeSlot - force a slot into the "materialized" state.
 *
 * This causes the slot's tuple to be a local copy not dependent on any
 * external storage (i.e. pointing into a Buffer, or having allocations in
 * another memory context).
 *
 * A typical use for this operation is to prepare a computed tuple for being
 * stored on disk.  The original data may or may not be virtual, but in any
 * case we need a private copy for heap_insert to scribble on.
 */
static inline void
ExecMaterializeSlot(TupleTableSlot *slot)
{
    slot->tts_ops->materialize(slot);
}
 
/*
 * ExecCopySlotHeapTuple - return HeapTuple allocated in caller's context
 */
static inline HeapTuple
ExecCopySlotHeapTuple(TupleTableSlot *slot)
{
    Assert(!TTS_EMPTY(slot));
 
    return slot->tts_ops->copy_heap_tuple(slot);
}
 
/*
 * ExecCopySlotMinimalTuple - return MinimalTuple allocated in caller's context
 */
static inline MinimalTuple
ExecCopySlotMinimalTuple(TupleTableSlot *slot)
{
    return slot->tts_ops->copy_minimal_tuple(slot, 0);
}
 
/*
 * ExecCopySlotMinimalTupleExtra - return MinimalTuple allocated in caller's
 * context, with extra bytes (maxaligned and zeroed) before the tuple for data
 * the caller wishes to store along with the tuple (without requiring the
 * caller to make an additional allocation).
 */
static inline MinimalTuple
ExecCopySlotMinimalTupleExtra(TupleTableSlot *slot, Size extra)
{
    return slot->tts_ops->copy_minimal_tuple(slot, extra);
}
 
/*
 * ExecCopySlot - copy one slot's contents into another.
 *
 * If a source's system attributes are supposed to be accessed in the target
 * slot, the target slot and source slot types need to match.
 *
 * Currently, 'dstslot' and 'srcslot' must have the same number of attributes.
 * Future work could see this relaxed to allow the source to contain
 * additional attributes and have the code here only copy over the leading
 * attributes.
 */
static inline TupleTableSlot *
ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
{
    Assert(!TTS_EMPTY(srcslot));
    Assert(srcslot != dstslot);
    Assert(dstslot->tts_tupleDescriptor->natts ==
           srcslot->tts_tupleDescriptor->natts);
 
    dstslot->tts_ops->copyslot(dstslot, srcslot);
 
    return dstslot;
}
 
#endif                          /* FRONTEND */
 
#endif                          /* TUPTABLE_H */

TTS_SHOULDFREE

#define TTS_SHOULDFREE

(

slot

)

(((slot)->tts_flags & TTS_FLAG_SHOULDFREE) != 0)

Definition at line 96 of file tuptable.h.

TupIsNull

#define TupIsNull

(

slot

)

((slot) == NULL || TTS_EMPTY(slot))

Definition at line 325 of file tuptable.h.

Typedef Documentation

BufferHeapTupleTableSlot

typedef struct BufferHeapTupleTableSlot BufferHeapTupleTableSlot

HeapTupleTableSlot

typedef struct HeapTupleTableSlot HeapTupleTableSlot

MinimalTupleTableSlot

typedef struct MinimalTupleTableSlot MinimalTupleTableSlot

TupleTableSlot

typedef struct TupleTableSlot TupleTableSlot

TupleTableSlotOps

typedef struct TupleTableSlotOps TupleTableSlotOps

Definition at line 117 of file tuptable.h.

VirtualTupleTableSlot

typedef struct VirtualTupleTableSlot VirtualTupleTableSlot

Function Documentation

ExecAllocTableSlot()

TupleTableSlot * ExecAllocTableSlot ( List **  tupleTable, TupleDesc  desc, const TupleTableSlotOps *  tts_ops, uint16  flags  )

extern

Definition at line 1437 of file execTuples.c.

{
    TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops, flags);
 
    *tupleTable = lappend(*tupleTable, slot);
 
    return slot;
}

References fb(), lappend(), and MakeTupleTableSlot().

Referenced by ExecInitExtraTupleSlot(), ExecInitIndexOnlyScan(), ExecInitResultSlot(), ExecInitScanTupleSlot(), and find_hash_columns().

ExecClearTuple()

static TupleTableSlot * ExecClearTuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 476 of file tuptable.h.

{
    slot->tts_ops->clear(slot);
 
    return slot;
}

References TupleTableSlotOps::clear, and TupleTableSlot::tts_ops.

Referenced by AfterTriggerExecute(), agg_retrieve_hash_table_in_memory(), apply_concurrent_changes(), apply_returning_filter(), ATRewriteTable(), begin_partition(), BitmapHeapNext(), buildSubPlanHash(), check_publications_origin_sequences(), check_publications_origin_tables(), CopyFrom(), CopyMultiInsertBufferFlush(), copyTemplateDependencies(), CteScanNext(), DefineTSConfiguration(), do_tup_output(), EnumValuesCreate(), eval_windowaggregates(), EvalPlanQual(), ExecAppend(), ExecAppendAsyncGetNext(), ExecARUpdateTriggers(), ExecBatchInsert(), ExecCheckTIDVisible(), ExecComputeStoredGenerated(), ExecDelete(), ExecDropSingleTupleTableSlot(), ExecEvalAggOrderedTransTuple(), ExecEvalPreOrderedDistinctMulti(), ExecFilterJunk(), ExecFindPartition(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecHashJoinGetSavedTuple(), ExecHashSubPlan(), ExecIncrementalSort(), ExecInsert(), ExecLockRows(), ExecMaterial(), ExecMergeAppend(), ExecOnConflictLockRow(), ExecOnConflictSelect(), ExecOnConflictUpdate(), ExecParallelHashJoinOuterGetTuple(), ExecProject(), ExecProjectSRF(), ExecReScanAgg(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanGroup(), ExecReScanIncrementalSort(), ExecReScanMaterial(), ExecReScanMergeJoin(), ExecReScanNamedTuplestoreScan(), ExecReScanSetOp(), ExecReScanSort(), ExecReScanTableFuncScan(), ExecReScanUnique(), ExecReScanValuesScan(), ExecReScanWindowAgg(), ExecReScanWorkTableScan(), ExecResetTupleTable(), ExecScanExtended(), ExecScanFetch(), ExecScanReScan(), ExecSetSlotDescriptor(), ExecSort(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), ExecUnique(), execute_attr_map_slot(), ExecWindowAgg(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), fileIterateForeignScan(), finalize_aggregates(), FunctionNext(), gather_getnext(), gather_merge_clear_tuples(), gather_merge_init(), get_actual_variable_endpoint(), get_returning_data(), hashagg_spill_tuple(), heap_getnextslot(), heap_getnextslot_tidrange(), heapam_scan_analyze_next_tuple(), heapam_scan_sample_next_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), InsertPgAttributeTuples(), MakeConfigurationMapping(), MergePartitionsMoveRows(), ordered_set_shutdown(), ordered_set_transition_multi(), pgoutput_row_filter(), postgresIterateDirectModify(), postgresIterateForeignScan(), postquel_get_single_result(), postquel_start(), prepare_hash_slot(), prepare_probe_slot(), process_ordered_aggregate_multi(), recordMultipleDependencies(), repack_store_change(), RunFromStore(), setop_load_group(), setop_retrieve_hash_table(), setop_retrieve_sorted(), ShutdownSetExpr(), slot_modify_data(), slot_store_data(), SplitPartitionMoveRows(), StoreIndexTuple(), switchToPresortedPrefixMode(), tablesample_getnext(), tfuncLoadRows(), TidNext(), TidRangeNext(), tts_buffer_heap_copyslot(), tuplesort_gettupleslot(), tuplestore_gettupleslot(), tuplestore_gettupleslot_force(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), ValuesNext(), and WinRowsArePeers().

ExecCopySlot()

static TupleTableSlot * ExecCopySlot ( TupleTableSlot *  dstslot, TupleTableSlot *  srcslot  )

inlinestatic

Definition at line 544 of file tuptable.h.

{
    Assert(!TTS_EMPTY(srcslot));
    Assert(srcslot != dstslot);
    Assert(dstslot->tts_tupleDescriptor->natts ==
           srcslot->tts_tupleDescriptor->natts);
 
    dstslot->tts_ops->copyslot(dstslot, srcslot);
 
    return dstslot;
}

References Assert, TupleTableSlotOps::copyslot, fb(), TupleDescData::natts, TTS_EMPTY, TupleTableSlot::tts_ops, and TupleTableSlot::tts_tupleDescriptor.

Referenced by AfterTriggerExecute(), AfterTriggerSaveEvent(), apply_handle_tuple_routing(), begin_partition(), build_index_value_desc(), CopyFrom(), CteScanNext(), EvalPlanQual(), ExecBRUpdateTriggers(), ExecEvalPreOrderedDistinctMulti(), ExecGetInsertNewTuple(), ExecGroup(), ExecIncrementalSort(), ExecInsert(), ExecLimit(), ExecMaterial(), ExecMemoize(), ExecUnique(), ExecWindowAgg(), postgresRecheckForeignScan(), RelationFindReplTupleSeq(), spool_tuples(), switchToPresortedPrefixMode(), update_frameheadpos(), and update_frametailpos().

ExecCopySlotHeapTuple()

static HeapTuple ExecCopySlotHeapTuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 504 of file tuptable.h.

{
    Assert(!TTS_EMPTY(slot));
 
    return slot->tts_ops->copy_heap_tuple(slot);
}

References Assert, TupleTableSlotOps::copy_heap_tuple, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by acquire_sample_rows(), agg_retrieve_direct(), ExecScanSubPlan(), ExecSetParamPlan(), reorderqueue_push(), ri_FastPathBatchAdd(), spi_printtup(), tts_buffer_heap_copyslot(), and tts_heap_copyslot().

ExecCopySlotMinimalTuple()

static MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 515 of file tuptable.h.

{
    return slot->tts_ops->copy_minimal_tuple(slot, 0);
}

References TupleTableSlotOps::copy_minimal_tuple, and TupleTableSlot::tts_ops.

Referenced by cache_lookup(), cache_store_tuple(), setop_load_group(), tts_minimal_copyslot(), tuplesort_puttupleslot(), and tuplestore_puttupleslot().

ExecCopySlotMinimalTupleExtra()

static MinimalTuple ExecCopySlotMinimalTupleExtra ( TupleTableSlot *  slot, Size  extra  )

inlinestatic

Definition at line 527 of file tuptable.h.

{
    return slot->tts_ops->copy_minimal_tuple(slot, extra);
}

References TupleTableSlotOps::copy_minimal_tuple, and TupleTableSlot::tts_ops.

Referenced by LookupTupleHashEntry_internal().

ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot ( TupleTableSlot *  slot )

extern

Definition at line 1520 of file execTuples.c.

{
    /* This should match ExecResetTupleTable's processing of one slot */
    Assert(IsA(slot, TupleTableSlot));
    ExecClearTuple(slot);
    slot->tts_ops->release(slot);
    if (slot->tts_tupleDescriptor)
        ReleaseTupleDesc(slot->tts_tupleDescriptor);
    if (!TTS_FIXED(slot))
    {
        if (slot->tts_values)
            pfree(slot->tts_values);
        if (slot->tts_isnull)
            pfree(slot->tts_isnull);
    }
    pfree(slot);
}

References Assert, ExecClearTuple(), IsA, pfree(), TupleTableSlotOps::release, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by acquire_sample_rows(), AfterTriggerFreeQuery(), afterTriggerInvokeEvents(), apply_concurrent_changes(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), check_pub_dead_tuple_retention(), check_publications_origin_sequences(), check_publications_origin_tables(), compute_expr_stats(), compute_index_stats(), copy_sequences(), CopyMultiInsertBufferCleanup(), CopyRelationTo(), copyTemplateDependencies(), DefineTSConfiguration(), deleteSplitPartitionContext(), end_tup_output(), EnumValuesCreate(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), FindConflictTuple(), freestate_cluster(), get_actual_variable_range(), get_rel_sync_entry(), heap_entry_is_visible(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), MergePartitionsMoveRows(), pgoutput_change(), recordMultipleDependencies(), RelationFindDeletedTupleInfoByIndex(), RelationFindDeletedTupleInfoSeq(), RelationFindReplTupleSeq(), repack_cleanup_logical_decoding(), ri_FastPathCheck(), ri_FastPathTeardown(), RI_Initial_Check(), RunFromStore(), SplitPartitionMoveRows(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), unique_key_recheck(), validate_remote_info(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

ExecFetchSlotHeapTuple()

HeapTuple ExecFetchSlotHeapTuple ( TupleTableSlot *  slot, bool  materialize, bool *  shouldFree  )

extern

Definition at line 1916 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(!TTS_EMPTY(slot));
 
    /* Materialize the tuple so that the slot "owns" it, if requested. */
    if (materialize)
        slot->tts_ops->materialize(slot);
 
    if (slot->tts_ops->get_heap_tuple == NULL)
    {
        if (shouldFree)
            *shouldFree = true;
        return slot->tts_ops->copy_heap_tuple(slot);
    }
    else
    {
        if (shouldFree)
            *shouldFree = false;
        return slot->tts_ops->get_heap_tuple(slot);
    }
}

References Assert, TupleTableSlotOps::copy_heap_tuple, fb(), TupleTableSlotOps::get_heap_tuple, TupleTableSlotOps::materialize, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by AfterTriggerExecute(), apply_returning_filter(), CatalogTuplesMultiInsertWithInfo(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecFetchSlotHeapTupleDatum(), ExecForPortionOfLeftovers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), heap_multi_insert(), heapam_relation_copy_for_cluster(), heapam_tuple_complete_speculative(), heapam_tuple_insert(), heapam_tuple_insert_speculative(), heapam_tuple_update(), systable_getnext(), systable_getnext_ordered(), systable_recheck_tuple(), update_most_recent_deletion_info(), and validateForeignKeyConstraint().

ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum ( TupleTableSlot *  slot )

extern

Definition at line 1995 of file execTuples.c.

{
    HeapTuple   tup;
    TupleDesc   tupdesc;
    bool        shouldFree;
    Datum       ret;
 
    /* Fetch slot's contents in regular-physical-tuple form */
    tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
    tupdesc = slot->tts_tupleDescriptor;
 
    /* Convert to Datum form */
    ret = heap_copy_tuple_as_datum(tup, tupdesc);
 
    if (shouldFree)
        pfree(tup);
 
    return ret;
}

References ExecFetchSlotHeapTuple(), fb(), heap_copy_tuple_as_datum(), pfree(), and TupleTableSlot::tts_tupleDescriptor.

Referenced by CopyToJsonOneRow(), ExecMakeFunctionResultSet(), and postquel_get_single_result().

ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot *  slot, bool *  shouldFree  )

extern

Definition at line 1964 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(!TTS_EMPTY(slot));
 
    if (slot->tts_ops->get_minimal_tuple)
    {
        if (shouldFree)
            *shouldFree = false;
        return slot->tts_ops->get_minimal_tuple(slot);
    }
    else
    {
        if (shouldFree)
            *shouldFree = true;
        return slot->tts_ops->copy_minimal_tuple(slot, 0);
    }
}

References Assert, TupleTableSlotOps::copy_minimal_tuple, fb(), TupleTableSlotOps::get_minimal_tuple, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by ExecHashJoinImpl(), ExecHashSkewTableInsert(), ExecHashTableInsert(), ExecParallelHashJoinPartitionOuter(), ExecParallelHashTableInsert(), ExecParallelHashTableInsertCurrentBatch(), hashagg_spill_tuple(), and tqueueReceiveSlot().

ExecForceStoreHeapTuple()

void ExecForceStoreHeapTuple ( HeapTuple  tuple, TupleTableSlot *  slot, bool  shouldFree  )

extern

Definition at line 1741 of file execTuples.c.

{
    if (TTS_IS_HEAPTUPLE(slot))
    {
        ExecStoreHeapTuple(tuple, slot, shouldFree);
    }
    else if (TTS_IS_BUFFERTUPLE(slot))
    {
        MemoryContext oldContext;
        BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 
        ExecClearTuple(slot);
        slot->tts_flags &= ~TTS_FLAG_EMPTY;
        oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
        bslot->base.tuple = heap_copytuple(tuple);
        slot->tts_flags |= TTS_FLAG_SHOULDFREE;
        MemoryContextSwitchTo(oldContext);
 
        if (shouldFree)
            pfree(tuple);
    }
    else
    {
        ExecClearTuple(slot);
        heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
                          slot->tts_values, slot->tts_isnull);
        ExecStoreVirtualTuple(slot);
 
        if (shouldFree)
        {
            ExecMaterializeSlot(slot);
            pfree(tuple);
        }
    }
}

References ExecClearTuple(), ExecMaterializeSlot(), ExecStoreHeapTuple(), ExecStoreVirtualTuple(), fb(), heap_copytuple(), heap_deform_tuple(), MemoryContextSwitchTo(), pfree(), TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TTS_IS_BUFFERTUPLE, TTS_IS_HEAPTUPLE, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by agg_retrieve_direct(), ExecARDeleteTriggers(), ExecARUpdateTriggers(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecDelete(), ExecForPortionOfLeftovers(), ExecIRDeleteTriggers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecMergeMatched(), ExecModifyTable(), IndexNextWithReorder(), IndexOnlyNext(), restore_tuple(), and store_returning_result().

ExecForceStoreMinimalTuple()

void ExecForceStoreMinimalTuple ( MinimalTuple  mtup, TupleTableSlot *  slot, bool  shouldFree  )

extern

Definition at line 1784 of file execTuples.c.

{
    if (TTS_IS_MINIMALTUPLE(slot))
    {
        tts_minimal_store_tuple(slot, mtup, shouldFree);
    }
    else
    {
        HeapTupleData htup;
 
        ExecClearTuple(slot);
 
        htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
        htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
        heap_deform_tuple(&htup, slot->tts_tupleDescriptor,
                          slot->tts_values, slot->tts_isnull);
        ExecStoreVirtualTuple(slot);
 
        if (shouldFree)
        {
            ExecMaterializeSlot(slot);
            pfree(mtup);
        }
    }
}

References ExecClearTuple(), ExecMaterializeSlot(), ExecStoreVirtualTuple(), fb(), heap_deform_tuple(), MINIMAL_TUPLE_OFFSET, pfree(), HeapTupleData::t_data, HeapTupleData::t_len, TTS_IS_MINIMALTUPLE, TupleTableSlot::tts_isnull, tts_minimal_store_tuple(), TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by ExecHashJoinGetSavedTuple(), ExecParallelHashJoinNewBatch(), ExecParallelHashJoinOuterGetTuple(), and tuplestore_gettupleslot_force().

ExecMaterializeSlot()

static void ExecMaterializeSlot ( TupleTableSlot *  slot )

inlinestatic

Definition at line 495 of file tuptable.h.

{
    slot->tts_ops->materialize(slot);
}

References TupleTableSlotOps::materialize, and TupleTableSlot::tts_ops.

Referenced by CopyFrom(), EvalPlanQual(), ExecBRUpdateTriggers(), ExecComputeStoredGenerated(), ExecDelete(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecForPortionOfLeftovers(), ExecInsert(), ExecOnConflictSelect(), ExecOnConflictUpdate(), ExecUpdateAct(), ExecUpdatePrologue(), RelationFindReplTupleByIndex(), and sqlfunction_receive().

ExecResetTupleTable()

void ExecResetTupleTable ( List *  tupleTable, bool  shouldFree  )

extern

Definition at line 1457 of file execTuples.c.

{
    ListCell   *lc;
 
    foreach(lc, tupleTable)
    {
        TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);
 
        /* Always release resources and reset the slot to empty */
        ExecClearTuple(slot);
        slot->tts_ops->release(slot);
        if (slot->tts_tupleDescriptor)
        {
            ReleaseTupleDesc(slot->tts_tupleDescriptor);
            slot->tts_tupleDescriptor = NULL;
        }
 
        /* If shouldFree, release memory occupied by the slot itself */
        if (shouldFree)
        {
            if (!TTS_FIXED(slot))
            {
                if (slot->tts_values)
                    pfree(slot->tts_values);
                if (slot->tts_isnull)
                    pfree(slot->tts_isnull);
            }
            pfree(slot);
        }
    }
 
    /* If shouldFree, release the list structure */
    if (shouldFree)
        list_free(tupleTable);
}

References ExecClearTuple(), fb(), lfirst_node, list_free(), pfree(), TupleTableSlotOps::release, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by afterTriggerInvokeEvents(), CopyFrom(), EvalPlanQualEnd(), ExecEndPlan(), and finish_edata().

ExecSetSlotDescriptor()

void ExecSetSlotDescriptor ( TupleTableSlot *  slot, TupleDesc  tupdesc  )

extern

Definition at line 1555 of file execTuples.c.

{
    Assert(!TTS_FIXED(slot));
 
    /* For safety, make sure slot is empty before changing it */
    ExecClearTuple(slot);
 
    /*
     * Release any old descriptor.  Also release old Datum/isnull arrays if
     * present (we don't bother to check if they could be re-used).
     */
    if (slot->tts_tupleDescriptor)
        ReleaseTupleDesc(slot->tts_tupleDescriptor);
 
    if (slot->tts_values)
        pfree(slot->tts_values);
    if (slot->tts_isnull)
        pfree(slot->tts_isnull);
 
    /*
     * Install the new descriptor; if it's refcounted, bump its refcount.
     */
    slot->tts_tupleDescriptor = tupdesc;
    PinTupleDesc(tupdesc);
 
    /*
     * Allocate Datum/isnull arrays of the appropriate size.  These must have
     * the same lifetime as the slot, so allocate in the slot's own context.
     */
    slot->tts_values = (Datum *)
        MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
 
    /*
     * We round the size of tts_isnull up to the next highest multiple of 8.
     * This is needed as populate_isnull_array() operates on 8 elements at a
     * time when converting a tuple's NULL bitmap into a boolean array.
     */
    slot->tts_isnull = (bool *)
        MemoryContextAlloc(slot->tts_mcxt, TYPEALIGN(8, tupdesc->natts * sizeof(bool)));
}

References Assert, ExecClearTuple(), MemoryContextAlloc(), TupleDescData::natts, pfree(), PinTupleDesc, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and TYPEALIGN.

Referenced by ExecAssignScanType(), ExecInitJunkFilter(), and ExecInitJunkFilterConversion().

ExecStoreAllNullTuple()

TupleTableSlot * ExecStoreAllNullTuple ( TupleTableSlot *  slot )

extern

Definition at line 1848 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
 
    /* Clear any old contents */
    ExecClearTuple(slot);
 
    /*
     * Fill all the columns of the virtual tuple with nulls
     */
    MemSet(slot->tts_values, 0,
           slot->tts_tupleDescriptor->natts * sizeof(Datum));
    memset(slot->tts_isnull, true,
           slot->tts_tupleDescriptor->natts * sizeof(bool));
 
    return ExecStoreVirtualTuple(slot);
}

References Assert, ExecClearTuple(), ExecStoreVirtualTuple(), fb(), MemSet, TupleDescData::natts, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by ATRewriteTable(), ExecDelete(), ExecGetAllNullSlot(), ExecInitNullTupleSlot(), get_returning_data(), and prepare_projection_slot().

ExecStoreBufferHeapTuple()

TupleTableSlot * ExecStoreBufferHeapTuple ( HeapTuple  tuple, TupleTableSlot *  slot, Buffer  buffer  )

extern

Definition at line 1664 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
    Assert(BufferIsValid(buffer));
 
    if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
        elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
    tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
 
    slot->tts_tableOid = tuple->t_tableOid;
 
    return slot;
}

References Assert, BufferIsValid(), elog, ERROR, fb(), HeapTupleData::t_tableOid, tts_buffer_heap_store_tuple(), TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by heap_getnextslot(), heap_getnextslot_tidrange(), heapam_index_build_range_scan(), heapam_index_fetch_tuple(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_tuple(), and heapam_scan_sample_next_tuple().

ExecStoreHeapTuple()

TupleTableSlot * ExecStoreHeapTuple ( HeapTuple  tuple, TupleTableSlot *  slot, bool  shouldFree  )

extern

Definition at line 1624 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
 
    if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
        elog(ERROR, "trying to store a heap tuple into wrong type of slot");
    tts_heap_store_tuple(slot, tuple, shouldFree);
 
    slot->tts_tableOid = tuple->t_tableOid;
 
    return slot;
}

References Assert, elog, ERROR, fb(), HeapTupleData::t_tableOid, tts_heap_store_tuple(), TTS_IS_HEAPTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by CatalogIndexInsert(), comparetup_cluster_tiebreak(), compute_expr_stats(), compute_index_stats(), ExecForceStoreHeapTuple(), ExecuteCallStmt(), get_returning_data(), heapam_index_validate_scan(), make_build_data(), pgoutput_change(), postgresIterateForeignScan(), repack_store_change(), ri_FastPathBatchFlush(), ri_FastPathFlushArray(), ri_FastPathFlushLoop(), and tts_heap_copyslot().

ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data, TupleTableSlot *  slot  )

extern

Definition at line 1878 of file execTuples.c.

{
    HeapTupleData tuple = {0};
    HeapTupleHeader td;
 
    td = DatumGetHeapTupleHeader(data);
 
    tuple.t_len = HeapTupleHeaderGetDatumLength(td);
    tuple.t_self = td->t_ctid;
    tuple.t_data = td;
 
    ExecClearTuple(slot);
 
    heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
                      slot->tts_values, slot->tts_isnull);
    ExecStoreVirtualTuple(slot);
}

References data, DatumGetHeapTupleHeader, ExecClearTuple(), ExecStoreVirtualTuple(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by EvalPlanQualFetchRowMark().

ExecStoreMinimalTuple()

TupleTableSlot * ExecStoreMinimalTuple ( MinimalTuple  mtup, TupleTableSlot *  slot, bool  shouldFree  )

extern

Definition at line 1718 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(mtup != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
 
    if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
        elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
    tts_minimal_store_tuple(slot, mtup, shouldFree);
 
    return slot;
}

References Assert, elog, ERROR, fb(), TTS_IS_MINIMALTUPLE, tts_minimal_store_tuple(), TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by agg_refill_hash_table(), agg_retrieve_hash_table_in_memory(), ExecMemoize(), ExecParallelScanHashBucket(), ExecParallelScanHashTableForUnmatched(), ExecScanHashBucket(), ExecScanHashTableForUnmatched(), findPartialMatch(), gather_getnext(), gather_merge_readnext(), MemoizeHash_equal(), prepare_probe_slot(), setop_load_group(), setop_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash_internal(), TupleHashTableMatch(), tuplesort_gettupleslot(), and tuplestore_gettupleslot().

ExecStorePinnedBufferHeapTuple()

TupleTableSlot * ExecStorePinnedBufferHeapTuple ( HeapTuple  tuple, TupleTableSlot *  slot, Buffer  buffer  )

extern

Definition at line 1690 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(tuple != NULL);
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
    Assert(BufferIsValid(buffer));
 
    if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
        elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
    tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
 
    slot->tts_tableOid = tuple->t_tableOid;
 
    return slot;
}

References Assert, BufferIsValid(), elog, ERROR, fb(), HeapTupleData::t_tableOid, tts_buffer_heap_store_tuple(), TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by heapam_fetch_row_version(), and heapam_tuple_lock().

ExecStoreVirtualTuple()

TupleTableSlot * ExecStoreVirtualTuple ( TupleTableSlot *  slot )

extern

Definition at line 1824 of file execTuples.c.

{
    /*
     * sanity checks
     */
    Assert(slot != NULL);
    Assert(slot->tts_tupleDescriptor != NULL);
    Assert(TTS_EMPTY(slot));
 
    slot->tts_flags &= ~TTS_FLAG_EMPTY;
    slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
 
    return slot;
}

References Assert, fb(), TupleDescData::natts, TTS_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_tupleDescriptor.

Referenced by agg_retrieve_hash_table_in_memory(), apply_returning_filter(), ATRewriteTable(), CopyFrom(), copyTemplateDependencies(), DefineTSConfiguration(), do_tup_output(), EnumValuesCreate(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecEvalPreOrderedDistinctMulti(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecSort(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hashagg_spill_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), InsertPgAttributeTuples(), MakeConfigurationMapping(), MergePartitionsMoveRows(), ordered_set_transition_multi(), pgoutput_row_filter(), prepare_hash_slot(), prepare_probe_slot(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_data(), slot_store_data(), SplitPartitionMoveRows(), StoreIndexTuple(), and ValuesNext().

MakeSingleTupleTableSlot()

TupleTableSlot * MakeSingleTupleTableSlot ( TupleDesc  tupdesc, const TupleTableSlotOps *  tts_ops  )

extern

Definition at line 1504 of file execTuples.c.

{
    TupleTableSlot *slot = MakeTupleTableSlot(tupdesc, tts_ops, 0);
 
    return slot;
}

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), apply_concurrent_changes(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTable(), CatalogIndexInsert(), check_pub_dead_tuple_retention(), check_publications_origin_sequences(), check_publications_origin_tables(), compute_expr_stats(), compute_index_stats(), copy_sequences(), copyTemplateDependencies(), DefineTSConfiguration(), EnumValuesCreate(), ExecInitIncrementalSort(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitMemoize(), ExecInitPartitionDispatchInfo(), ExecInsert(), ExecPrepareTuplestoreResult(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), GetAfterTriggersStoreSlot(), heapam_index_validate_scan(), hypothetical_dense_rank_final(), init_execution_state(), init_tuple_slot(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), ordered_set_startup(), pgoutput_row_filter(), recordMultipleDependencies(), repack_store_change(), ri_FastPathGetEntry(), RI_Initial_Check(), RI_PartitionRemove_Check(), RunFromStore(), table_slot_create(), tstoreStartupReceiver(), tuplesort_begin_cluster(), and validate_remote_info().

MakeTupleTableSlot()

TupleTableSlot * MakeTupleTableSlot ( TupleDesc  tupleDesc, const TupleTableSlotOps *  tts_ops, uint16  flags  )

extern

Definition at line 1358 of file execTuples.c.

{
    Size        basesz,
                allocsz;
    TupleTableSlot *slot;
 
    basesz = tts_ops->base_slot_size;
 
    /* Ensure callers don't have any way to set transient flags permanently */
    flags &= ~TTS_FLAGS_TRANSIENT;
 
    /*
     * When a fixed descriptor is specified, we can reduce overhead by
     * allocating the entire slot in one go.
     *
     * We round the size of tts_isnull up to the next highest multiple of 8.
     * This is needed as populate_isnull_array() operates on 8 elements at a
     * time when converting a tuple's NULL bitmap into a boolean array.
     */
    if (tupleDesc)
        allocsz = MAXALIGN(basesz) +
            MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
            TYPEALIGN(8, tupleDesc->natts * sizeof(bool));
    else
        allocsz = basesz;
 
    slot = palloc0(allocsz);
    /* const for optimization purposes, OK to modify at allocation time */
    *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
    slot->type = T_TupleTableSlot;
    slot->tts_flags = TTS_FLAG_EMPTY | flags;
    if (tupleDesc != NULL)
        slot->tts_flags |= TTS_FLAG_FIXED;
    slot->tts_tupleDescriptor = tupleDesc;
    slot->tts_mcxt = CurrentMemoryContext;
    slot->tts_nvalid = 0;
 
    if (tupleDesc != NULL)
    {
        slot->tts_values = (Datum *)
            (((char *) slot)
             + MAXALIGN(basesz));
 
        slot->tts_isnull = (bool *)
            (((char *) slot)
             + MAXALIGN(basesz)
             + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
 
        PinTupleDesc(tupleDesc);
 
        /*
         * Precalculate the maximum guaranteed attribute that has to exist in
         * every tuple which gets deformed into this slot.  When the
         * TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS flag is enabled, we simply take
         * the pre-calculated value from the tupleDesc, otherwise the
         * optimization is disabled, and we set the value to 0.
         */
        if ((flags & TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS) != 0)
            slot->tts_first_nonguaranteed = tupleDesc->firstNonGuaranteedAttr;
        else
            slot->tts_first_nonguaranteed = 0;
    }
 
    /*
     * And allow slot type specific initialization.
     */
    slot->tts_ops->init(slot);
 
    return slot;
}

References TupleTableSlotOps::base_slot_size, CurrentMemoryContext, fb(), TupleTableSlotOps::init, MAXALIGN, palloc0(), PinTupleDesc, TupleTableSlot::tts_first_nonguaranteed, TTS_FLAG_EMPTY, TTS_FLAG_FIXED, TTS_FLAG_OBEYS_NOT_NULL_CONSTRAINTS, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleTableSlot::type, and TYPEALIGN.

Referenced by ExecAllocTableSlot(), ExecConstraints(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), MakeSingleTupleTableSlot(), pgoutput_change(), and ReportNotNullViolationError().

slot_attisnull()

static bool slot_attisnull ( TupleTableSlot *  slot, int  attnum  )

inlinestatic

Definition at line 403 of file tuptable.h.

{
    Assert(attnum > 0);
 
    if (attnum > slot->tts_nvalid)
        slot_getsomeattrs(slot, attnum);
 
    return slot->tts_isnull[attnum - 1];
}

References Assert, attnum, slot_getsomeattrs(), TupleTableSlot::tts_isnull, and TupleTableSlot::tts_nvalid.

Referenced by adjust_toast_pointers(), ATRewriteTable(), ExecConstraints(), repack_store_change(), restore_tuple(), ri_NullCheck(), slotAllNulls(), slotNoNulls(), and validateDomainNotNullConstraint().

slot_getallattrs()

static void slot_getallattrs ( TupleTableSlot *  slot )

inlinestatic

Definition at line 390 of file tuptable.h.

{
    slot_getsomeattrs(slot, slot->tts_tupleDescriptor->natts);
}

References TupleDescData::natts, slot_getsomeattrs(), and TupleTableSlot::tts_tupleDescriptor.

Referenced by agg_retrieve_hash_table_in_memory(), apply_handle_tuple_routing(), apply_returning_filter(), ATRewriteTable(), CopyOneRowTo(), CopyRelationTo(), ExecBuildSlotValueDescription(), ExecComputeStoredGenerated(), ExecEvalWholeRowVar(), ExecFilterJunk(), ExecForPortionOfLeftovers(), execute_attr_map_slot(), FunctionNext(), logicalrep_write_tuple(), MemoizeHash_equal(), MergePartitionsMoveRows(), pgoutput_row_filter(), prepare_probe_slot(), printsimple(), printtup(), serializeAnalyzeReceive(), setop_compare_slots(), slot_modify_data(), SplitPartitionMoveRows(), tstoreReceiveSlot_detoast(), tts_virtual_copyslot(), and tuples_equal().

slot_getattr()

static Datum slot_getattr ( TupleTableSlot *  slot, int  attnum, bool *  isnull  )

inlinestatic

Definition at line 417 of file tuptable.h.

{
    Assert(attnum > 0);
 
    if (attnum > slot->tts_nvalid)
        slot_getsomeattrs(slot, attnum);
 
    *isnull = slot->tts_isnull[attnum - 1];
 
    return slot->tts_values[attnum - 1];
}

References Assert, attnum, slot_getsomeattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_values.

Referenced by buildSubPlanHash(), check_pub_dead_tuple_retention(), check_publications_origin_sequences(), check_publications_origin_tables(), convert_prep_stmt_params(), debugtup(), ExecGetJunkAttribute(), ExecJustAssignVarImpl(), ExecJustVarImpl(), ExecMakeFunctionResultSet(), ExecNestLoop(), ExecScanSubPlan(), ExecSetParamPlan(), execTuplesUnequal(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), FormIndexDatum(), FormPartitionKeyDatum(), get_and_validate_seq_info(), heap_compare_slots(), heap_compare_slots(), hypothetical_dense_rank_final(), hypothetical_rank_common(), isCurrentGroup(), postquel_get_single_result(), ri_ExtractValues(), ri_FastPathFlushArray(), ri_KeysEqual(), ri_ReportViolation(), update_frameheadpos(), update_frametailpos(), validate_remote_info(), and validateDomainCheckConstraint().

slot_getmissingattrs()

void slot_getmissingattrs ( TupleTableSlot *  slot, int  startAttNum, int  lastAttNum  )

extern

Definition at line 2141 of file execTuples.c.

{
    AttrMissing *attrmiss = NULL;
 
    /* Check for invalid attnums */
    if (unlikely(lastAttNum > slot->tts_tupleDescriptor->natts))
        elog(ERROR, "invalid attribute number %d", lastAttNum);
 
    if (slot->tts_tupleDescriptor->constr)
        attrmiss = slot->tts_tupleDescriptor->constr->missing;
 
    if (!attrmiss)
    {
        /* no missing values array at all, so just fill everything in as NULL */
        for (int attnum = startAttNum; attnum < lastAttNum; attnum++)
        {
            slot->tts_values[attnum] = (Datum) 0;
            slot->tts_isnull[attnum] = true;
        }
    }
    else
    {
        /* use attrmiss to set the missing values */
        for (int attnum = startAttNum; attnum < lastAttNum; attnum++)
        {
            slot->tts_values[attnum] = attrmiss[attnum].am_value;
            slot->tts_isnull[attnum] = !attrmiss[attnum].am_present;
        }
    }
}

References attnum, TupleDescData::constr, elog, ERROR, fb(), TupleConstr::missing, TupleDescData::natts, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and unlikely.

Referenced by slot_deform_heap_tuple().

slot_getsomeattrs()

static void slot_getsomeattrs ( TupleTableSlot *  slot, int  attnum  )

inlinestatic

Definition at line 376 of file tuptable.h.

{
    /* Populate slot with attributes up to 'attnum', if it's not already */
    if (slot->tts_nvalid < attnum)
        slot->tts_ops->getsomeattrs(slot, attnum);
}

References attnum, TupleTableSlotOps::getsomeattrs, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_ops.

Referenced by adjust_toast_pointers(), ExecInterpExpr(), ExecJustHashInnerVarWithIV(), ExecJustHashOuterVarStrict(), ExecJustHashVarImpl(), ExecSort(), hashagg_spill_tuple(), identity_key_equal(), prepare_hash_slot(), prepare_projection_slot(), process_ordered_aggregate_multi(), repack_store_change(), restore_tuple(), slot_attisnull(), slot_getallattrs(), and slot_getattr().

slot_getsomeattrs_int()

void slot_getsomeattrs_int ( TupleTableSlot *  slot, int  attnum  )

extern

Definition at line 2177 of file execTuples.c.

{
    /* Check for caller errors */
    Assert(slot->tts_nvalid < attnum);  /* checked in slot_getsomeattrs */
    Assert(attnum > 0);
 
    /* Fetch as many attributes as possible from the underlying tuple. */
    slot->tts_ops->getsomeattrs(slot, attnum);
 
    /*
     * Avoid putting new code here as that would prevent the compiler from
     * using the sibling call optimization for the above function.
     */
}

References Assert, attnum, TupleTableSlotOps::getsomeattrs, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_ops.

slot_getsysattr()

static Datum slot_getsysattr ( TupleTableSlot *  slot, int  attnum, bool *  isnull  )

inlinestatic

Definition at line 438 of file tuptable.h.

{
    Assert(attnum < 0);         /* caller error */
 
    if (attnum == TableOidAttributeNumber)
    {
        *isnull = false;
        return ObjectIdGetDatum(slot->tts_tableOid);
    }
    else if (attnum == SelfItemPointerAttributeNumber)
    {
        *isnull = false;
        return PointerGetDatum(&slot->tts_tid);
    }
 
    /* Fetch the system attribute from the underlying tuple. */
    return slot->tts_ops->getsysattr(slot, attnum, isnull);
}

References Assert, attnum, TupleTableSlotOps::getsysattr, ObjectIdGetDatum(), PointerGetDatum, SelfItemPointerAttributeNumber, TableOidAttributeNumber, TupleTableSlot::tts_ops, TupleTableSlot::tts_tableOid, and TupleTableSlot::tts_tid.

Referenced by ExecCheckTupleVisible(), execCurrentOf(), ExecEvalSysVar(), ExecOnConflictLockRow(), FormIndexDatum(), and GetTupleTransactionInfo().

slot_is_current_xact_tuple()

static bool slot_is_current_xact_tuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 467 of file tuptable.h.

{
    return slot->tts_ops->is_current_xact_tuple(slot);
}

References TupleTableSlotOps::is_current_xact_tuple, and TupleTableSlot::tts_ops.

Referenced by RI_FKey_fk_upd_check_required().

Variable Documentation

TTSOpsBufferHeapTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsBufferHeapTuple

extern

Definition at line 87 of file execTuples.c.

Referenced by CheckOpSlotCompatibility(), heapam_slot_callbacks(), and slot_compile_deform().

TTSOpsHeapTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsHeapTuple

extern

Definition at line 85 of file execTuples.c.

Referenced by CatalogIndexInsert(), CheckOpSlotCompatibility(), compute_expr_stats(), compute_index_stats(), copyTemplateDependencies(), DefineTSConfiguration(), EnumValuesCreate(), ExecInitForeignScan(), ExecuteCallStmt(), heapam_index_validate_scan(), init_tuple_slot(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), recordMultipleDependencies(), repack_store_change(), ri_FastPathGetEntry(), slot_compile_deform(), table_slot_callbacks(), and tuplesort_begin_cluster().

TTSOpsMinimalTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsMinimalTuple

extern

Definition at line 86 of file execTuples.c.

Referenced by afterTriggerInvokeEvents(), build_pertrans_for_aggref(), BuildTupleHashTable(), check_pub_dead_tuple_retention(), check_publications_origin_sequences(), check_publications_origin_tables(), copy_sequences(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHash(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitMemoize(), ExecInitNamedTuplestoreScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), ExecInitWorkTableScan(), ExecPrepareTuplestoreResult(), fetch_relation_list(), fetch_remote_slots(), fetch_remote_table_info(), find_hash_columns(), gather_merge_setup(), hashagg_recompile_expressions(), hypothetical_dense_rank_final(), init_execution_state(), ordered_set_startup(), RunFromStore(), slot_compile_deform(), and validate_remote_info().

TTSOpsVirtual

PGDLLIMPORT const TupleTableSlotOps TTSOpsVirtual

extern

Definition at line 84 of file execTuples.c.

Referenced by apply_concurrent_changes(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), buildSubPlanHash(), CheckOpSlotCompatibility(), CreateReplicationSlot(), ExecComputeSlotInfo(), ExecConditionalAssignProjectionInfo(), ExecConstraints(), ExecGetResultSlotOps(), ExecInitAgg(), ExecInitAppend(), ExecInitCustomScan(), ExecInitForPortionOf(), ExecInitGroup(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitPartitionDispatchInfo(), ExecInitProjectSet(), ExecInitResult(), ExecInitSort(), ExecInitSubPlan(), ExecInitValuesScan(), ExecInitWholeRowVar(), ExecInitWindowAgg(), ExecPartitionCheckEmitError(), ExecWaitStmt(), ExecWithCheckOptions(), ExplainQuery(), GetAfterTriggersStoreSlot(), IdentifySystem(), InitPlan(), llvm_compile_expr(), pgoutput_change(), pgoutput_row_filter(), ReadReplicationSlot(), ReportNotNullViolationError(), RI_Initial_Check(), RI_PartitionRemove_Check(), SendTablespaceList(), SendXlogRecPtrResult(), ShowAllGUCConfig(), ShowGUCConfigOption(), slot_compile_deform(), StartReplication(), table_slot_callbacks(), and tstoreStartupReceiver().