tuptable.h File Reference

#include "access/htup.h"
#include "access/htup_details.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 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 261 of file tuptable.h.

FIELDNO_HEAPTUPLETABLESLOT_TUPLE

#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1

Definition at line 259 of file tuptable.h.

FIELDNO_MINIMALTUPLETABLESLOT_OFF

#define FIELDNO_MINIMALTUPLETABLESLOT_OFF   4

Definition at line 299 of file tuptable.h.

FIELDNO_MINIMALTUPLETABLESLOT_TUPLE

#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1

Definition at line 295 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_FLAGS

#define FIELDNO_TUPLETABLESLOT_FLAGS   1

Definition at line 117 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_ISNULL

#define FIELDNO_TUPLETABLESLOT_ISNULL   6

Definition at line 126 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_NVALID

#define FIELDNO_TUPLETABLESLOT_NVALID   2

Definition at line 119 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR

#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4

Definition at line 122 of file tuptable.h.

FIELDNO_TUPLETABLESLOT_VALUES

#define FIELDNO_TUPLETABLESLOT_VALUES   5

Definition at line 124 of file tuptable.h.

TTS_EMPTY

#define TTS_EMPTY

(

slot

)

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

Definition at line 96 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 95 of file tuptable.h.

TTS_FLAG_FIXED

#define TTS_FLAG_FIXED   (1 << 4)

Definition at line 107 of file tuptable.h.

TTS_FLAG_SHOULDFREE

#define TTS_FLAG_SHOULDFREE   (1 << 2)

Definition at line 99 of file tuptable.h.

TTS_FLAG_SLOW

#define TTS_FLAG_SLOW   (1 << 3)

Definition at line 103 of file tuptable.h.

TTS_IS_BUFFERTUPLE

#define TTS_IS_BUFFERTUPLE

(

slot

)

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

Definition at line 237 of file tuptable.h.

TTS_IS_HEAPTUPLE

#define TTS_IS_HEAPTUPLE

(

slot

)

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

Definition at line 235 of file tuptable.h.

TTS_IS_MINIMALTUPLE

#define TTS_IS_MINIMALTUPLE

(

slot

)

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

Definition at line 236 of file tuptable.h.

TTS_IS_VIRTUAL

#define TTS_IS_VIRTUAL

(

slot

)

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

Definition at line 234 of file tuptable.h.

TTS_SHOULDFREE

#define TTS_SHOULDFREE

(

slot

)

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

Definition at line 100 of file tuptable.h.

TTS_SLOW

#define TTS_SLOW

(

slot

)

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

Definition at line 104 of file tuptable.h.

TupIsNull

#define TupIsNull

(

slot

)

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

Definition at line 306 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 1 of file tuptable.h.

VirtualTupleTableSlot

typedef struct VirtualTupleTableSlot VirtualTupleTableSlot

Function Documentation

ExecAllocTableSlot()

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

Definition at line 1258 of file execTuples.c.

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

References lappend(), and MakeTupleTableSlot().

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

ExecClearTuple()

static TupleTableSlot* ExecClearTuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 454 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(), 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(), ExecLockRows(), ExecMaterial(), ExecMergeAppend(), ExecOnConflictUpdate(), ExecParallelHashJoinOuterGetTuple(), ExecProject(), ExecProjectSRF(), ExecReScanAgg(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanGroup(), ExecReScanIncrementalSort(), ExecReScanMaterial(), ExecReScanMergeJoin(), ExecReScanNamedTuplestoreScan(), ExecReScanSetOp(), ExecReScanSort(), ExecReScanTableFuncScan(), ExecReScanUnique(), ExecReScanValuesScan(), ExecReScanWindowAgg(), ExecReScanWorkTableScan(), ExecResetTupleTable(), ExecScan(), ExecScanFetch(), ExecScanReScan(), ExecSetSlotDescriptor(), ExecSort(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), ExecUnique(), execute_attr_map_slot(), ExecWindowAgg(), fetch_remote_table_info(), fetch_table_list(), 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(), ordered_set_shutdown(), ordered_set_transition_multi(), pgoutput_row_filter(), postgresIterateDirectModify(), postgresIterateForeignScan(), prepare_hash_slot(), prepare_probe_slot(), process_ordered_aggregate_multi(), recordMultipleDependencies(), RunFromStore(), setop_retrieve_direct(), setop_retrieve_hash_table(), ShutdownSetExpr(), slot_modify_data(), slot_store_data(), StoreIndexTuple(), switchToPresortedPrefixMode(), synchronize_slots(), 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 509 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, 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 481 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(), setop_retrieve_direct(), spi_printtup(), tts_buffer_heap_copyslot(), and tts_heap_copyslot().

ExecCopySlotMinimalTuple()

static MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot *  slot )

inlinestatic

Definition at line 492 of file tuptable.h.

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

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

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

ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot

(

TupleTableSlot *

slot

)

Definition at line 1341 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_publications(), check_publications_origin(), compute_expr_stats(), compute_index_stats(), CopyMultiInsertBufferCleanup(), copyTemplateDependencies(), DefineTSConfiguration(), DoCopyTo(), end_tup_output(), EnumValuesCreate(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), 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(), pgoutput_change(), recordMultipleDependencies(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

ExecFetchSlotHeapTuple()

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

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

ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum

(

TupleTableSlot *

slot

)

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

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

References Assert, TupleTableSlotOps::copy_minimal_tuple, 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
	)

Definition at line 1556 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(), heap_copytuple(), heap_deform_tuple(), MemoryContextSwitchTo(), pfree(), TTS_FLAG_EMPTY, 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
	)

Definition at line 1599 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(), heap_deform_tuple(), MINIMAL_TUPLE_OFFSET, pfree(), HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::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 472 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(), ExecUpdateAct(), ExecUpdatePrologue(), and RelationFindReplTupleByIndex().

ExecResetTupleTable()

void ExecResetTupleTable	(	List *	tupleTable,
		bool	shouldFree
	)

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

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

)

Definition at line 1663 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(), MemSet, TupleDescData::natts, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

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

ExecStoreBufferHeapTuple()

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

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

Definition at line 1439 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, 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(), setop_retrieve_direct(), and tts_heap_copyslot().

ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum	(	Datum	data,
		TupleTableSlot *	slot
	)

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

Definition at line 1533 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, 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_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash_internal(), TupleHashTableMatch(), tuplesort_gettupleslot(), and tuplestore_gettupleslot().

ExecStorePinnedBufferHeapTuple()

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

Definition at line 1505 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, 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

)

Definition at line 1639 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, TupleDescData::natts, TTS_EMPTY, TTS_FLAG_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(), 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(), StoreIndexTuple(), and ValuesNext().

MakeSingleTupleTableSlot()

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

Definition at line 1325 of file execTuples.c.

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

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTableExt(), CatalogIndexInsert(), check_publications(), check_publications_origin(), compute_expr_stats(), compute_index_stats(), copyTemplateDependencies(), DefineTSConfiguration(), EnumValuesCreate(), ExecInitIncrementalSort(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitMemoize(), ExecInitPartitionDispatchInfo(), ExecInsert(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), GetAfterTriggersStoreSlot(), heapam_index_validate_scan(), hypothetical_dense_rank_final(), init_sql_fcache(), init_tuple_slot(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), ordered_set_startup(), pgoutput_row_filter(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), RunFromStore(), synchronize_slots(), table_slot_create(), tstoreStartupReceiver(), tuplesort_begin_cluster(), and validate_remote_info().

MakeTupleTableSlot()

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

Definition at line 1199 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, TupleTableSlotOps::init, MAXALIGN, TupleDescData::natts, 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(), and pgoutput_change().

slot_attisnull()

static bool slot_attisnull ( TupleTableSlot *  slot, int  attnum  )

inlinestatic

Definition at line 381 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 368 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(), DoCopyTo(), ExecBuildSlotValueDescription(), ExecComputeStoredGenerated(), ExecEvalWholeRowVar(), ExecFilterJunk(), execute_attr_map_slot(), FunctionNext(), logicalrep_write_tuple(), MemoizeHash_equal(), pgoutput_row_filter(), prepare_probe_slot(), printsimple(), printtup(), serializeAnalyzeReceive(), slot_modify_data(), tstoreReceiveSlot_detoast(), tts_virtual_copyslot(), and tuples_equal().

slot_getattr()

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

inlinestatic

Definition at line 395 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_publications(), check_publications_origin(), convert_prep_stmt_params(), debugtup(), ExecGetJunkAttribute(), ExecJustAssignVarImpl(), ExecJustVarImpl(), ExecMakeFunctionResultSet(), ExecNestLoop(), ExecScanSubPlan(), ExecSetParamPlan(), execTuplesUnequal(), fetch_remote_table_info(), fetch_table_list(), fetch_tuple_flag(), FormIndexDatum(), FormPartitionKeyDatum(), heap_compare_slots(), hypothetical_dense_rank_final(), hypothetical_rank_common(), isCurrentGroup(), postquel_get_single_result(), ri_ExtractValues(), ri_KeysEqual(), ri_ReportViolation(), synchronize_slots(), TupleHashTableHash_internal(), update_frameheadpos(), update_frametailpos(), validate_remote_info(), and validateDomainCheckConstraint().

slot_getmissingattrs()

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

Definition at line 1955 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 AttrMissing::am_present, AttrMissing::am_value, TupleDescData::constr, 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 355 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(), 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
	)

Definition at line 1989 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 416 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 445 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(), ExecInitSetOp(), 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(), BuildTupleHashTableExt(), check_publications(), check_publications_origin(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHash(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitMemoize(), ExecInitNamedTuplestoreScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), ExecInitWorkTableScan(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), find_hash_columns(), gather_merge_setup(), hashagg_recompile_expressions(), hypothetical_dense_rank_final(), init_sql_fcache(), ordered_set_startup(), RunFromStore(), slot_compile_deform(), synchronize_slots(), 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(), 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(), ExecWithCheckOptions(), ExplainQuery(), GetAfterTriggersStoreSlot(), IdentifySystem(), InitPlan(), pgoutput_change(), pgoutput_row_filter(), ReadReplicationSlot(), RI_Initial_Check(), RI_PartitionRemove_Check(), SendTablespaceList(), SendXlogRecPtrResult(), ShowAllGUCConfig(), ShowGUCConfigOption(), slot_compile_deform(), StartReplication(), table_slot_callbacks(), and tstoreStartupReceiver().