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_SLOW   (1 << 3)
#define	TTS_SLOW(slot)   (((slot)->tts_flags & TTS_FLAG_SLOW) != 0)
#define	TTS_FLAG_FIXED   (1 << 4)
#define	TTS_FIXED(slot)   (((slot)->tts_flags & TTS_FLAG_FIXED) != 0)
#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)
TupleTableSlot *	ExecAllocTableSlot (List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
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 264 of file tuptable.h.

FIELDNO_HEAPTUPLETABLESLOT_TUPLE

#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1

Definition at line 262 of file tuptable.h.

FIELDNO_MINIMALTUPLETABLESLOT_OFF

#define FIELDNO_MINIMALTUPLETABLESLOT_OFF   4

Definition at line 302 of file tuptable.h.

FIELDNO_MINIMALTUPLETABLESLOT_TUPLE

#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1

Definition at line 298 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_FLAGS

#define FIELDNO_TUPLETABLESLOT_FLAGS   1

Definition at line 116 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_ISNULL

#define FIELDNO_TUPLETABLESLOT_ISNULL   6

Definition at line 125 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_NVALID

#define FIELDNO_TUPLETABLESLOT_NVALID   2

Definition at line 118 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR

#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4

Definition at line 121 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_VALUES

#define FIELDNO_TUPLETABLESLOT_VALUES   5

Definition at line 123 of file tuptable.h.

TTS_EMPTY

#define TTS_EMPTY

(

slot

)

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

Definition at line 95 of file tuptable.h.

TTS_FIXED

#define TTS_FIXED

(

slot

)

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

Definition at line 107 of file tuptable.h.

TTS_FLAG_EMPTY

#define TTS_FLAG_EMPTY   (1 << 1)

Definition at line 94 of file tuptable.h.

TTS_FLAG_FIXED

#define TTS_FLAG_FIXED   (1 << 4)

Definition at line 106 of file tuptable.h.

TTS_FLAG_SHOULDFREE

#define TTS_FLAG_SHOULDFREE   (1 << 2)

Definition at line 98 of file tuptable.h.

TTS_FLAG_SLOW

#define TTS_FLAG_SLOW   (1 << 3)

Definition at line 102 of file tuptable.h.

TTS_IS_BUFFERTUPLE

#define TTS_IS_BUFFERTUPLE

(

slot

)

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

Definition at line 240 of file tuptable.h.

TTS_IS_HEAPTUPLE

#define TTS_IS_HEAPTUPLE

(

slot

)

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

Definition at line 238 of file tuptable.h.

TTS_IS_MINIMALTUPLE

#define TTS_IS_MINIMALTUPLE

(

slot

)

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

Definition at line 239 of file tuptable.h.

TTS_IS_VIRTUAL

#define TTS_IS_VIRTUAL

(

slot

)

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

Definition at line 237 of file tuptable.h.

TTS_SHOULDFREE

#define TTS_SHOULDFREE

(

slot

)

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

Definition at line 99 of file tuptable.h.

TTS_SLOW

#define TTS_SLOW

(

slot

)

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

Definition at line 103 of file tuptable.h.

TupIsNull

#define TupIsNull

(

slot

)

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

Definition at line 309 of file tuptable.h.

{
    if (slot->tts_nvalid < attnum)
        slot_getsomeattrs_int(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 */

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 110 of file tuptable.h.

VirtualTupleTableSlot

typedef struct VirtualTupleTableSlot VirtualTupleTableSlot

Function Documentation

ExecAllocTableSlot()

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

extern

Definition at line 1360 of file execTuples.c.

{
    TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);
 
    *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 457 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_returning_filter(), ATRewriteTable(), begin_partition(), BitmapHeapNext(), buildSubPlanHash(), check_publications(), 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(), 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(), 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(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), validate_remote_info(), ValuesNext(), and WinRowsArePeers().

ExecCopySlot()

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

inlinestatic

Definition at line 524 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 484 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(), spi_printtup(), tts_buffer_heap_copyslot(), and tts_heap_copyslot().

ExecCopySlotMinimalTuple()

static MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 495 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 507 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 1443 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(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), check_pub_dead_tuple_retention(), check_publications(), 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_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(), RI_Initial_Check(), RunFromStore(), SplitPartitionMoveRows(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), unique_key_recheck(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

ExecFetchSlotHeapTuple()

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

extern

Definition at line 1833 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(), 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 1912 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 ExecMakeFunctionResultSet(), and postquel_get_single_result().

ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot *  slot, bool *  shouldFree  )

extern

Definition at line 1881 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 1658 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(), ExecIRDeleteTriggers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecMergeMatched(), ExecModifyTable(), IndexNextWithReorder(), IndexOnlyNext(), and store_returning_result().

ExecForceStoreMinimalTuple()

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

extern

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

ExecMaterializeSlot()

static void ExecMaterializeSlot ( TupleTableSlot *  slot )

inlinestatic

Definition at line 475 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(), ExecInsert(), ExecOnConflictUpdate(), ExecUpdateAct(), ExecUpdatePrologue(), RelationFindReplTupleByIndex(), and sqlfunction_receive().

ExecResetTupleTable()

void ExecResetTupleTable ( List *  tupleTable, bool  shouldFree  )

extern

Definition at line 1380 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 1478 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));
    slot->tts_isnull = (bool *)
        MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
}

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

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

ExecStoreAllNullTuple()

TupleTableSlot * ExecStoreAllNullTuple ( TupleTableSlot *  slot )

extern

Definition at line 1765 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 1581 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 1541 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(), and tts_heap_copyslot().

ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data, TupleTableSlot *  slot  )

extern

Definition at line 1795 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 1635 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 1607 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 1741 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 1427 of file execTuples.c.

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

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTable(), CatalogIndexInsert(), check_pub_dead_tuple_retention(), check_publications(), 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(), 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  )

extern

Definition at line 1301 of file execTuples.c.

{
    Size        basesz,
                allocsz;
    TupleTableSlot *slot;
 
    basesz = tts_ops->base_slot_size;
 
    /*
     * When a fixed descriptor is specified, we can reduce overhead by
     * allocating the entire slot in one go.
     */
    if (tupleDesc)
        allocsz = MAXALIGN(basesz) +
            MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
            MAXALIGN(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;
    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);
    }
 
    /*
     * 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, TTS_FLAG_EMPTY, TTS_FLAG_FIXED, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and TupleTableSlot::type.

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 384 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 ATRewriteTable(), ExecConstraints(), ri_NullCheck(), slotAllNulls(), slotNoNulls(), and validateDomainNotNullConstraint().

slot_getallattrs()

static void slot_getallattrs ( TupleTableSlot *  slot )

inlinestatic

Definition at line 371 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(), 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 398 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(), 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_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 2057 of file execTuples.c.

{
    AttrMissing *attrmiss = NULL;
 
    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 */
        memset(slot->tts_values + startAttNum, 0,
               (lastAttNum - startAttNum) * sizeof(Datum));
        memset(slot->tts_isnull + startAttNum, 1,
               (lastAttNum - startAttNum) * sizeof(bool));
    }
    else
    {
        int         missattnum;
 
        /* if there is a missing values array we must process them one by one */
        for (missattnum = startAttNum;
             missattnum < lastAttNum;
             missattnum++)
        {
            slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
            slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
        }
    }
}

References TupleDescData::constr, fb(), TupleConstr::missing, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_getsomeattrs_int().

slot_getsomeattrs()

static void slot_getsomeattrs ( TupleTableSlot *  slot, int  attnum  )

inlinestatic

Definition at line 358 of file tuptable.h.

{
    if (slot->tts_nvalid < attnum)
        slot_getsomeattrs_int(slot, attnum);
}

References attnum, slot_getsomeattrs_int(), and TupleTableSlot::tts_nvalid.

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

slot_getsomeattrs_int()

void slot_getsomeattrs_int ( TupleTableSlot *  slot, int  attnum  )

extern

Definition at line 2091 of file execTuples.c.

{
    /* Check for caller errors */
    Assert(slot->tts_nvalid < attnum);  /* checked in slot_getsomeattrs */
    Assert(attnum > 0);
 
    if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
        elog(ERROR, "invalid attribute number %d", attnum);
 
    /* Fetch as many attributes as possible from the underlying tuple. */
    slot->tts_ops->getsomeattrs(slot, attnum);
 
    /*
     * If the underlying tuple doesn't have enough attributes, tuple
     * descriptor must have the missing attributes.
     */
    if (unlikely(slot->tts_nvalid < attnum))
    {
        slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
        slot->tts_nvalid = attnum;
    }
}

References Assert, attnum, elog, ERROR, TupleTableSlotOps::getsomeattrs, TupleDescData::natts, slot_getmissingattrs(), TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by slot_getsomeattrs().

slot_getsysattr()

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

inlinestatic

Definition at line 419 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(), ExecOnConflictUpdate(), FormIndexDatum(), and GetTupleTransactionInfo().

slot_is_current_xact_tuple()

static bool slot_is_current_xact_tuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 448 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(), 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(), 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_handle_delete(), apply_handle_insert(), apply_handle_update(), buildSubPlanHash(), CheckOpSlotCompatibility(), CreateReplicationSlot(), ExecComputeSlotInfo(), ExecConditionalAssignProjectionInfo(), ExecConstraints(), ExecGetResultSlotOps(), ExecInitAgg(), ExecInitAppend(), ExecInitCustomScan(), 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().