PostgreSQL Source Code  git master
Data Structures | Macros | Typedefs | Functions | Variables
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 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 251 of file tuptable.h.

Referenced by slot_compile_deform().

◆ FIELDNO_HEAPTUPLETABLESLOT_TUPLE

#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1

Definition at line 249 of file tuptable.h.

Referenced by slot_compile_deform().

◆ FIELDNO_MINIMALTUPLETABLESLOT_OFF

#define FIELDNO_MINIMALTUPLETABLESLOT_OFF   4

Definition at line 285 of file tuptable.h.

Referenced by slot_compile_deform().

◆ FIELDNO_MINIMALTUPLETABLESLOT_TUPLE

#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1

Definition at line 281 of file tuptable.h.

Referenced by slot_compile_deform().

◆ FIELDNO_TUPLETABLESLOT_FLAGS

#define FIELDNO_TUPLETABLESLOT_FLAGS   1

Definition at line 118 of file tuptable.h.

Referenced by slot_compile_deform().

◆ FIELDNO_TUPLETABLESLOT_ISNULL

#define FIELDNO_TUPLETABLESLOT_ISNULL   6

Definition at line 127 of file tuptable.h.

Referenced by llvm_compile_expr(), and slot_compile_deform().

◆ FIELDNO_TUPLETABLESLOT_NVALID

#define FIELDNO_TUPLETABLESLOT_NVALID   2

Definition at line 120 of file tuptable.h.

Referenced by llvm_compile_expr(), and slot_compile_deform().

◆ FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR

#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4

Definition at line 123 of file tuptable.h.

◆ FIELDNO_TUPLETABLESLOT_VALUES

#define FIELDNO_TUPLETABLESLOT_VALUES   5

Definition at line 125 of file tuptable.h.

Referenced by llvm_compile_expr(), and slot_compile_deform().

◆ TTS_EMPTY

#define TTS_EMPTY (   slot)    (((slot)->tts_flags & TTS_FLAG_EMPTY) != 0)

Definition at line 97 of file tuptable.h.

Referenced by ExecCopySlot(), ExecCopySlotHeapTuple(), ExecDelete(), ExecFetchSlotHeapTuple(), ExecFetchSlotMinimalTuple(), ExecStoreVirtualTuple(), prepare_projection_slot(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_copy_minimal_tuple(), tts_buffer_heap_get_heap_tuple(), tts_buffer_heap_getsomeattrs(), tts_buffer_heap_getsysattr(), tts_buffer_heap_materialize(), tts_heap_copy_heap_tuple(), tts_heap_get_heap_tuple(), tts_heap_getsomeattrs(), tts_heap_getsysattr(), tts_heap_materialize(), tts_minimal_getsomeattrs(), tts_minimal_materialize(), tts_minimal_store_tuple(), tts_virtual_copy_heap_tuple(), and tts_virtual_copy_minimal_tuple().

◆ TTS_FIXED

#define TTS_FIXED (   slot)    (((slot)->tts_flags & TTS_FLAG_FIXED) != 0)

Definition at line 109 of file tuptable.h.

Referenced by ExecDropSingleTupleTableSlot(), ExecGetResultSlotOps(), ExecJustAssignVarVirtImpl(), ExecJustVarVirtImpl(), ExecResetTupleTable(), and ExecSetSlotDescriptor().

◆ TTS_FLAG_EMPTY

#define TTS_FLAG_EMPTY   (1 << 1)

Definition at line 96 of file tuptable.h.

Referenced by ExecForceStoreHeapTuple(), ExecProject(), ExecStoreVirtualTuple(), MakeTupleTableSlot(), tts_buffer_heap_clear(), tts_buffer_heap_copyslot(), tts_buffer_heap_store_tuple(), tts_heap_clear(), tts_heap_store_tuple(), tts_minimal_clear(), tts_minimal_store_tuple(), tts_virtual_clear(), and tts_virtual_copyslot().

◆ TTS_FLAG_FIXED

#define TTS_FLAG_FIXED   (1 << 4)

Definition at line 108 of file tuptable.h.

Referenced by MakeTupleTableSlot().

◆ TTS_FLAG_SHOULDFREE

#define TTS_FLAG_SHOULDFREE   (1 << 2)

Definition at line 100 of file tuptable.h.

Referenced by ExecForceStoreHeapTuple(), tts_buffer_heap_clear(), tts_buffer_heap_copyslot(), tts_buffer_heap_materialize(), tts_buffer_heap_store_tuple(), tts_heap_clear(), tts_heap_materialize(), tts_heap_store_tuple(), tts_minimal_clear(), tts_minimal_materialize(), tts_minimal_store_tuple(), tts_virtual_clear(), and tts_virtual_materialize().

◆ TTS_FLAG_SLOW

#define TTS_FLAG_SLOW   (1 << 3)

Definition at line 104 of file tuptable.h.

Referenced by slot_compile_deform(), and slot_deform_heap_tuple().

◆ TTS_IS_BUFFERTUPLE

#define TTS_IS_BUFFERTUPLE (   slot)    ((slot)->tts_ops == &TTSOpsBufferHeapTuple)

Definition at line 231 of file tuptable.h.

Referenced by ExecForceStoreHeapTuple(), ExecStoreBufferHeapTuple(), ExecStorePinnedBufferHeapTuple(), heapam_fetch_row_version(), heapam_index_fetch_tuple(), heapam_scan_analyze_next_tuple(), heapam_tuple_lock(), and heapam_tuple_satisfies_snapshot().

◆ TTS_IS_HEAPTUPLE

#define TTS_IS_HEAPTUPLE (   slot)    ((slot)->tts_ops == &TTSOpsHeapTuple)

Definition at line 229 of file tuptable.h.

Referenced by ExecForceStoreHeapTuple(), and ExecStoreHeapTuple().

◆ TTS_IS_MINIMALTUPLE

#define TTS_IS_MINIMALTUPLE (   slot)    ((slot)->tts_ops == &TTSOpsMinimalTuple)

Definition at line 230 of file tuptable.h.

Referenced by ExecForceStoreMinimalTuple(), and ExecStoreMinimalTuple().

◆ TTS_IS_VIRTUAL

#define TTS_IS_VIRTUAL (   slot)    ((slot)->tts_ops == &TTSOpsVirtual)

Definition at line 228 of file tuptable.h.

Referenced by ExecJustAssignVarVirtImpl(), and ExecJustVarVirtImpl().

◆ TTS_SHOULDFREE

#define TTS_SHOULDFREE (   slot)    (((slot)->tts_flags & TTS_FLAG_SHOULDFREE) != 0)

Definition at line 101 of file tuptable.h.

Referenced by tts_buffer_heap_clear(), tts_buffer_heap_copyslot(), tts_buffer_heap_materialize(), tts_buffer_heap_store_tuple(), tts_heap_clear(), tts_heap_materialize(), tts_minimal_clear(), tts_minimal_materialize(), tts_minimal_store_tuple(), tts_virtual_clear(), and tts_virtual_materialize().

◆ TTS_SLOW

#define TTS_SLOW (   slot)    (((slot)->tts_flags & TTS_FLAG_SLOW) != 0)

Definition at line 105 of file tuptable.h.

Referenced by slot_deform_heap_tuple().

◆ TupIsNull

#define TupIsNull (   slot)    ((slot) == NULL || TTS_EMPTY(slot))

Definition at line 292 of file tuptable.h.

Referenced by AfterTriggerSaveEvent(), agg_fill_hash_table(), agg_retrieve_direct(), begin_partition(), buildSubPlanHash(), check_constant_qual(), CteScanNext(), eval_windowaggregates(), EvalPlanQual(), EvalPlanQualFetchRowMark(), ExecAgg(), ExecAppend(), ExecCrossPartitionUpdate(), execCurrentOf(), ExecDelete(), ExecGather(), ExecGatherMerge(), ExecGroup(), ExecHashJoinImpl(), ExecHashJoinOuterGetTuple(), ExecIncrementalSort(), ExecLimit(), ExecLockRows(), ExecMaterial(), ExecMergeAppend(), ExecMergeJoin(), ExecModifyTable(), ExecNestLoop(), ExecParallelHashJoinOuterGetTuple(), ExecParallelHashJoinPartitionOuter(), ExecPostprocessPlan(), ExecProcNodeInstr(), ExecProjectSet(), ExecRecursiveUnion(), ExecResult(), ExecScan(), ExecScanFetch(), ExecScanSubPlan(), ExecSetParamPlan(), ExecSort(), ExecUnique(), ExecUpdate(), ExecutePlan(), fetch_input_tuple(), ForeignNext(), FunctionNext(), gather_getnext(), gather_merge_init(), gather_merge_readnext(), GetTupleForTrigger(), heap_compare_slots(), hypothetical_dense_rank_final(), MJEvalInnerValues(), MJEvalOuterValues(), MultiExecParallelHash(), MultiExecPrivateHash(), postgresRecheckForeignScan(), print_slot(), setop_fill_hash_table(), setop_retrieve_direct(), spool_tuples(), switchToPresortedPrefixMode(), update_frameheadpos(), and update_frametailpos().

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 112 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 1141 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

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

1143 {
1144  TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);
1145 
1146  *tupleTable = lappend(*tupleTable, slot);
1147 
1148  return slot;
1149 }
lappend
List * lappend(List *list, void *datum)
Definition: list.c:321
MakeTupleTableSlot
TupleTableSlot * MakeTupleTableSlot(TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1082

◆ ExecClearTuple()

static TupleTableSlot* ExecClearTuple ( TupleTableSlot *  slot)
inlinestatic

Definition at line 425 of file tuptable.h.

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

Referenced by AfterTriggerExecute(), agg_retrieve_hash_table_in_memory(), apply_handle_update_internal(), apply_returning_filter(), ATRewriteTable(), begin_partition(), BitmapHeapNext(), buildSubPlanHash(), CopyFrom(), CopyMultiInsertBufferFlush(), copyTemplateDependencies(), CteScanNext(), do_tup_output(), eval_windowaggregates(), EvalPlanQual(), ExecAppend(), ExecARUpdateTriggers(), ExecCheckTIDVisible(), ExecComputeStoredGenerated(), ExecDelete(), ExecDropSingleTupleTableSlot(), ExecEndAgg(), ExecEndBitmapHeapScan(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHashJoin(), ExecEndIncrementalSort(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndMaterial(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNamedTuplestoreScan(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndValuesScan(), ExecEndWindowAgg(), ExecEndWorkTableScan(), ExecEvalAggOrderedTransTuple(), 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(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), ExecUnique(), execute_attr_map_slot(), ExecWindowAgg(), fetch_remote_table_info(), fetch_table_list(), fileIterateForeignScan(), FunctionNext(), gather_getnext(), gather_merge_clear_tuples(), gather_merge_init(), get_actual_variable_endpoint(), get_returning_data(), hashagg_spill_tuple(), heap_getnextslot(), heapam_scan_analyze_next_tuple(), heapam_scan_sample_next_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), InsertPgAttributeTuples(), ordered_set_shutdown(), ordered_set_transition_multi(), postgresIterateDirectModify(), postgresIterateForeignScan(), prepare_hash_slot(), process_ordered_aggregate_multi(), recordMultipleDependencies(), RunFromStore(), setop_retrieve_direct(), setop_retrieve_hash_table(), ShutdownSetExpr(), slot_modify_data(), slot_store_data(), StoreIndexTuple(), switchToPresortedPrefixMode(), tablesample_getnext(), tfuncLoadRows(), TidNext(), tts_buffer_heap_copyslot(), tuplesort_gettupleslot(), tuplestore_gettupleslot(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), ValuesNext(), and WinRowsArePeers().

426 {
427  slot->tts_ops->clear(slot);
428 
429  return slot;
430 }
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::clear
void(* clear)(TupleTableSlot *slot)
Definition: tuptable.h:152

◆ ExecCopySlot()

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

Definition at line 475 of file tuptable.h.

References Assert, AssertArg, TupleTableSlotOps::copyslot, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by apply_handle_tuple_routing(), begin_partition(), CopyFrom(), CteScanNext(), EvalPlanQual(), ExecBRUpdateTriggers(), ExecGroup(), ExecIncrementalSort(), ExecLimit(), ExecMaterial(), ExecModifyTable(), ExecUnique(), ExecWindowAgg(), postgresRecheckForeignScan(), RelationFindReplTupleSeq(), spool_tuples(), switchToPresortedPrefixMode(), update_frameheadpos(), and update_frametailpos().

476 {
477  Assert(!TTS_EMPTY(srcslot));
478  AssertArg(srcslot != dstslot);
479 
480  dstslot->tts_ops->copyslot(dstslot, srcslot);
481 
482  return dstslot;
483 }
TTS_EMPTY
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
AssertArg
#define AssertArg(condition)
Definition: c.h:748
Assert
#define Assert(condition)
Definition: c.h:746
TupleTableSlotOps::copyslot
void(* copyslot)(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: tuptable.h:180

◆ ExecCopySlotHeapTuple()

static HeapTuple ExecCopySlotHeapTuple ( TupleTableSlot *  slot)
inlinestatic

Definition at line 452 of file tuptable.h.

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().

453 {
454  Assert(!TTS_EMPTY(slot));
455 
456  return slot->tts_ops->copy_heap_tuple(slot);
457 }
TupleTableSlotOps::copy_heap_tuple
HeapTuple(* copy_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:206
TTS_EMPTY
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
Assert
#define Assert(condition)
Definition: c.h:746

◆ ExecCopySlotMinimalTuple()

static MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot *  slot)
inlinestatic

Definition at line 463 of file tuptable.h.

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

Referenced by copytup_heap(), LookupTupleHashEntry_internal(), tts_minimal_copyslot(), and tuplestore_puttupleslot().

464 {
465  return slot->tts_ops->copy_minimal_tuple(slot);
466 }
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::copy_minimal_tuple
MinimalTuple(* copy_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:216

◆ ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot ( TupleTableSlot *  slot)

Definition at line 1224 of file execTuples.c.

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(), afterTriggerInvokeEvents(), AlterDomainNotNull(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), compute_index_stats(), CopyMultiInsertBufferCleanup(), copyTemplateDependencies(), CopyTo(), DefineQueryRewrite(), end_tup_output(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), InsertPgAttributeTuples(), recordMultipleDependencies(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), tuplesort_free(), unique_key_recheck(), validateDomainConstraint(), and validateForeignKeyConstraint().

1225 {
1226  /* This should match ExecResetTupleTable's processing of one slot */
1227  Assert(IsA(slot, TupleTableSlot));
1228  ExecClearTuple(slot);
1229  slot->tts_ops->release(slot);
1230  if (slot->tts_tupleDescriptor)
1231  ReleaseTupleDesc(slot->tts_tupleDescriptor);
1232  if (!TTS_FIXED(slot))
1233  {
1234  if (slot->tts_values)
1235  pfree(slot->tts_values);
1236  if (slot->tts_isnull)
1237  pfree(slot->tts_isnull);
1238  }
1239  pfree(slot);
1240 }
TTS_FIXED
#define TTS_FIXED(slot)
Definition: tuptable.h:109
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:579
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::release
void(* release)(TupleTableSlot *slot)
Definition: tuptable.h:144
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Assert
#define Assert(condition)
Definition: c.h:746
ReleaseTupleDesc
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122

◆ ExecFetchSlotHeapTuple()

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

Definition at line 1614 of file execTuples.c.

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().

1615 {
1616  /*
1617  * sanity checks
1618  */
1619  Assert(slot != NULL);
1620  Assert(!TTS_EMPTY(slot));
1621 
1622  /* Materialize the tuple so that the slot "owns" it, if requested. */
1623  if (materialize)
1624  slot->tts_ops->materialize(slot);
1625 
1626  if (slot->tts_ops->get_heap_tuple == NULL)
1627  {
1628  if (shouldFree)
1629  *shouldFree = true;
1630  return slot->tts_ops->copy_heap_tuple(slot);
1631  }
1632  else
1633  {
1634  if (shouldFree)
1635  *shouldFree = false;
1636  return slot->tts_ops->get_heap_tuple(slot);
1637  }
1638 }
TupleTableSlotOps::copy_heap_tuple
HeapTuple(* copy_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:206
TTS_EMPTY
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::get_heap_tuple
HeapTuple(* get_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:188
Assert
#define Assert(condition)
Definition: c.h:746
TupleTableSlotOps::materialize
void(* materialize)(TupleTableSlot *slot)
Definition: tuptable.h:174

◆ ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum ( TupleTableSlot *  slot)

Definition at line 1693 of file execTuples.c.

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

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

1694 {
1695  HeapTuple tup;
1696  TupleDesc tupdesc;
1697  bool shouldFree;
1698  Datum ret;
1699 
1700  /* Fetch slot's contents in regular-physical-tuple form */
1701  tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
1702  tupdesc = slot->tts_tupleDescriptor;
1703 
1704  /* Convert to Datum form */
1705  ret = heap_copy_tuple_as_datum(tup, tupdesc);
1706 
1707  if (shouldFree)
1708  pfree(tup);
1709 
1710  return ret;
1711 }
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
ExecFetchSlotHeapTuple
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition: execTuples.c:1614
heap_copy_tuple_as_datum
Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
Definition: heaptuple.c:984
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Datum
uintptr_t Datum
Definition: postgres.h:367

◆ ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot *  slot,
bool *  shouldFree 
)

Definition at line 1662 of file execTuples.c.

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().

1664 {
1665  /*
1666  * sanity checks
1667  */
1668  Assert(slot != NULL);
1669  Assert(!TTS_EMPTY(slot));
1670 
1671  if (slot->tts_ops->get_minimal_tuple)
1672  {
1673  if (shouldFree)
1674  *shouldFree = false;
1675  return slot->tts_ops->get_minimal_tuple(slot);
1676  }
1677  else
1678  {
1679  if (shouldFree)
1680  *shouldFree = true;
1681  return slot->tts_ops->copy_minimal_tuple(slot);
1682  }
1683 }
TTS_EMPTY
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::get_minimal_tuple
MinimalTuple(* get_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:196
TupleTableSlotOps::copy_minimal_tuple
MinimalTuple(* copy_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:216
Assert
#define Assert(condition)
Definition: c.h:746

◆ ExecForceStoreHeapTuple()

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

Definition at line 1439 of file execTuples.c.

References BufferHeapTupleTableSlot::base, 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, TupleTableSlot::tts_values, and HeapTupleTableSlot::tuple.

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

1442 {
1443  if (TTS_IS_HEAPTUPLE(slot))
1444  {
1445  ExecStoreHeapTuple(tuple, slot, shouldFree);
1446  }
1447  else if (TTS_IS_BUFFERTUPLE(slot))
1448  {
1449  MemoryContext oldContext;
1450  BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
1451 
1452  ExecClearTuple(slot);
1453  slot->tts_flags &= ~TTS_FLAG_EMPTY;
1454  oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
1455  bslot->base.tuple = heap_copytuple(tuple);
1456  slot->tts_flags |= TTS_FLAG_SHOULDFREE;
1457  MemoryContextSwitchTo(oldContext);
1458 
1459  if (shouldFree)
1460  pfree(tuple);
1461  }
1462  else
1463  {
1464  ExecClearTuple(slot);
1465  heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
1466  slot->tts_values, slot->tts_isnull);
1467  ExecStoreVirtualTuple(slot);
1468 
1469  if (shouldFree)
1470  {
1471  ExecMaterializeSlot(slot);
1472  pfree(tuple);
1473  }
1474  }
1475 }
heap_copytuple
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
TTS_FLAG_EMPTY
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
TTS_FLAG_SHOULDFREE
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
HeapTupleTableSlot::tuple
HeapTuple tuple
Definition: tuptable.h:250
TupleTableSlot::tts_mcxt
MemoryContext tts_mcxt
Definition: tuptable.h:129
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot::tts_flags
uint16 tts_flags
Definition: tuptable.h:119
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
TTS_IS_BUFFERTUPLE
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:231
ExecMaterializeSlot
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:443
TTS_IS_HEAPTUPLE
#define TTS_IS_HEAPTUPLE(slot)
Definition: tuptable.h:229
heap_deform_tuple
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
BufferHeapTupleTableSlot::base
HeapTupleTableSlot base
Definition: tuptable.h:259
ExecStoreHeapTuple
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition: execTuples.c:1322
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522

◆ ExecForceStoreMinimalTuple()

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

Definition at line 1482 of file execTuples.c.

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().

1485 {
1486  if (TTS_IS_MINIMALTUPLE(slot))
1487  {
1488  tts_minimal_store_tuple(slot, mtup, shouldFree);
1489  }
1490  else
1491  {
1492  HeapTupleData htup;
1493 
1494  ExecClearTuple(slot);
1495 
1496  htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
1497  htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
1498  heap_deform_tuple(&htup, slot->tts_tupleDescriptor,
1499  slot->tts_values, slot->tts_isnull);
1500  ExecStoreVirtualTuple(slot);
1501 
1502  if (shouldFree)
1503  {
1504  ExecMaterializeSlot(slot);
1505  pfree(mtup);
1506  }
1507  }
1508 }
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
HeapTupleHeader
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
TTS_IS_MINIMALTUPLE
#define TTS_IS_MINIMALTUPLE(slot)
Definition: tuptable.h:230
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
HeapTupleData::t_len
uint32 t_len
Definition: htup.h:64
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
tts_minimal_store_tuple
static void tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
Definition: execTuples.c:599
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
ExecMaterializeSlot
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:443
MINIMAL_TUPLE_OFFSET
#define MINIMAL_TUPLE_OFFSET
Definition: htup_details.h:619
heap_deform_tuple
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522

◆ ExecMaterializeSlot()

static void ExecMaterializeSlot ( TupleTableSlot *  slot)
inlinestatic

Definition at line 443 of file tuptable.h.

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

Referenced by CopyFrom(), EvalPlanQual(), ExecBRUpdateTriggers(), ExecComputeStoredGenerated(), ExecDelete(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecInsert(), ExecUpdate(), and RelationFindReplTupleByIndex().

444 {
445  slot->tts_ops->materialize(slot);
446 }
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::materialize
void(* materialize)(TupleTableSlot *slot)
Definition: tuptable.h:174

◆ ExecResetTupleTable()

void ExecResetTupleTable ( List *  tupleTable,
bool  shouldFree 
)

Definition at line 1161 of file execTuples.c.

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(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), CopyFrom(), EvalPlanQualEnd(), and ExecEndPlan().

1163 {
1164  ListCell *lc;
1165 
1166  foreach(lc, tupleTable)
1167  {
1168  TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);
1169 
1170  /* Always release resources and reset the slot to empty */
1171  ExecClearTuple(slot);
1172  slot->tts_ops->release(slot);
1173  if (slot->tts_tupleDescriptor)
1174  {
1175  ReleaseTupleDesc(slot->tts_tupleDescriptor);
1176  slot->tts_tupleDescriptor = NULL;
1177  }
1178 
1179  /* If shouldFree, release memory occupied by the slot itself */
1180  if (shouldFree)
1181  {
1182  if (!TTS_FIXED(slot))
1183  {
1184  if (slot->tts_values)
1185  pfree(slot->tts_values);
1186  if (slot->tts_isnull)
1187  pfree(slot->tts_isnull);
1188  }
1189  pfree(slot);
1190  }
1191  }
1192 
1193  /* If shouldFree, release the list structure */
1194  if (shouldFree)
1195  list_free(tupleTable);
1196 }
TTS_FIXED
#define TTS_FIXED(slot)
Definition: tuptable.h:109
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlotOps::release
void(* release)(TupleTableSlot *slot)
Definition: tuptable.h:144
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
lfirst_node
#define lfirst_node(type, lc)
Definition: pg_list.h:172
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
list_free
void list_free(List *list)
Definition: list.c:1376
ReleaseTupleDesc
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122

◆ ExecSetSlotDescriptor()

void ExecSetSlotDescriptor ( TupleTableSlot *  slot,
TupleDesc  tupdesc 
)

Definition at line 1259 of file execTuples.c.

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(), ExecInitJunkFilterConversion(), and ExecInitJunkFilterInsertion().

1261 {
1262  Assert(!TTS_FIXED(slot));
1263 
1264  /* For safety, make sure slot is empty before changing it */
1265  ExecClearTuple(slot);
1266 
1267  /*
1268  * Release any old descriptor. Also release old Datum/isnull arrays if
1269  * present (we don't bother to check if they could be re-used).
1270  */
1271  if (slot->tts_tupleDescriptor)
1272  ReleaseTupleDesc(slot->tts_tupleDescriptor);
1273 
1274  if (slot->tts_values)
1275  pfree(slot->tts_values);
1276  if (slot->tts_isnull)
1277  pfree(slot->tts_isnull);
1278 
1279  /*
1280  * Install the new descriptor; if it's refcounted, bump its refcount.
1281  */
1282  slot->tts_tupleDescriptor = tupdesc;
1283  PinTupleDesc(tupdesc);
1284 
1285  /*
1286  * Allocate Datum/isnull arrays of the appropriate size. These must have
1287  * the same lifetime as the slot, so allocate in the slot's own context.
1288  */
1289  slot->tts_values = (Datum *)
1290  MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
1291  slot->tts_isnull = (bool *)
1292  MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
1293 }
TTS_FIXED
#define TTS_FIXED(slot)
Definition: tuptable.h:109
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
TupleTableSlot::tts_mcxt
MemoryContext tts_mcxt
Definition: tuptable.h:129
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
pfree
void pfree(void *pointer)
Definition: mcxt.c:1057
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Datum
uintptr_t Datum
Definition: postgres.h:367
Assert
#define Assert(condition)
Definition: c.h:746
PinTupleDesc
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116
MemoryContextAlloc
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:797
ReleaseTupleDesc
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122

◆ ExecStoreAllNullTuple()

TupleTableSlot* ExecStoreAllNullTuple ( TupleTableSlot *  slot)

Definition at line 1546 of file execTuples.c.

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

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

1547 {
1548  /*
1549  * sanity checks
1550  */
1551  Assert(slot != NULL);
1552  Assert(slot->tts_tupleDescriptor != NULL);
1553 
1554  /* Clear any old contents */
1555  ExecClearTuple(slot);
1556 
1557  /*
1558  * Fill all the columns of the virtual tuple with nulls
1559  */
1560  MemSet(slot->tts_values, 0,
1561  slot->tts_tupleDescriptor->natts * sizeof(Datum));
1562  memset(slot->tts_isnull, true,
1563  slot->tts_tupleDescriptor->natts * sizeof(bool));
1564 
1565  return ExecStoreVirtualTuple(slot);
1566 }
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
MemSet
#define MemSet(start, val, len)
Definition: c.h:950
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Datum
uintptr_t Datum
Definition: postgres.h:367
Assert
#define Assert(condition)
Definition: c.h:746
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522

◆ ExecStoreBufferHeapTuple()

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

Definition at line 1362 of file execTuples.c.

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(), 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().

1365 {
1366  /*
1367  * sanity checks
1368  */
1369  Assert(tuple != NULL);
1370  Assert(slot != NULL);
1371  Assert(slot->tts_tupleDescriptor != NULL);
1372  Assert(BufferIsValid(buffer));
1373 
1374  if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1375  elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1376  tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
1377 
1378  slot->tts_tableOid = tuple->t_tableOid;
1379 
1380  return slot;
1381 }
TupleTableSlot::tts_tableOid
Oid tts_tableOid
Definition: tuptable.h:131
tts_buffer_heap_store_tuple
static void tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
Definition: execTuples.c:829
ERROR
#define ERROR
Definition: elog.h:43
HeapTupleData::t_tableOid
Oid t_tableOid
Definition: htup.h:66
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
TTS_IS_BUFFERTUPLE
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:231
Assert
#define Assert(condition)
Definition: c.h:746
BufferIsValid
#define BufferIsValid(bufnum)
Definition: bufmgr.h:123
elog
#define elog(elevel,...)
Definition: elog.h:214
unlikely
#define unlikely(x)
Definition: c.h:207

◆ ExecStoreHeapTuple()

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

Definition at line 1322 of file execTuples.c.

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(), compute_index_stats(), ExecForceStoreHeapTuple(), ExecuteCallStmt(), get_returning_data(), heapam_index_validate_scan(), postgresIterateForeignScan(), setop_retrieve_direct(), and tts_heap_copyslot().

1325 {
1326  /*
1327  * sanity checks
1328  */
1329  Assert(tuple != NULL);
1330  Assert(slot != NULL);
1331  Assert(slot->tts_tupleDescriptor != NULL);
1332 
1333  if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
1334  elog(ERROR, "trying to store a heap tuple into wrong type of slot");
1335  tts_heap_store_tuple(slot, tuple, shouldFree);
1336 
1337  slot->tts_tableOid = tuple->t_tableOid;
1338 
1339  return slot;
1340 }
TupleTableSlot::tts_tableOid
Oid tts_tableOid
Definition: tuptable.h:131
ERROR
#define ERROR
Definition: elog.h:43
HeapTupleData::t_tableOid
Oid t_tableOid
Definition: htup.h:66
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
TTS_IS_HEAPTUPLE
#define TTS_IS_HEAPTUPLE(slot)
Definition: tuptable.h:229
Assert
#define Assert(condition)
Definition: c.h:746
elog
#define elog(elevel,...)
Definition: elog.h:214
tts_heap_store_tuple
static void tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
Definition: execTuples.c:431
unlikely
#define unlikely(x)
Definition: c.h:207

◆ ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data,
TupleTableSlot *  slot 
)

Definition at line 1576 of file execTuples.c.

References 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().

1577 {
1578  HeapTupleData tuple = {0};
1579  HeapTupleHeader td;
1580 
1581  td = DatumGetHeapTupleHeader(data);
1582 
1583  tuple.t_len = HeapTupleHeaderGetDatumLength(td);
1584  tuple.t_self = td->t_ctid;
1585  tuple.t_data = td;
1586 
1587  ExecClearTuple(slot);
1588 
1589  heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
1590  slot->tts_values, slot->tts_isnull);
1591  ExecStoreVirtualTuple(slot);
1592 }
ExecClearTuple
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
DatumGetHeapTupleHeader
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:294
HeapTupleData::t_data
HeapTupleHeader t_data
Definition: htup.h:68
HeapTupleHeaderData::t_ctid
ItemPointerData t_ctid
Definition: htup_details.h:160
HeapTupleData::t_self
ItemPointerData t_self
Definition: htup.h:65
HeapTupleData::t_len
uint32 t_len
Definition: htup.h:64
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
heap_deform_tuple
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
ExecStoreVirtualTuple
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522
HeapTupleHeaderGetDatumLength
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecStoreMinimalTuple()

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

Definition at line 1416 of file execTuples.c.

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(), ExecParallelScanHashBucket(), ExecScanHashBucket(), ExecScanHashTableForUnmatched(), findPartialMatch(), gather_getnext(), gather_merge_readnext(), setop_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash_internal(), TupleHashTableMatch(), tuplesort_gettupleslot(), and tuplestore_gettupleslot().

1419 {
1420  /*
1421  * sanity checks
1422  */
1423  Assert(mtup != NULL);
1424  Assert(slot != NULL);
1425  Assert(slot->tts_tupleDescriptor != NULL);
1426 
1427  if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
1428  elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
1429  tts_minimal_store_tuple(slot, mtup, shouldFree);
1430 
1431  return slot;
1432 }
TTS_IS_MINIMALTUPLE
#define TTS_IS_MINIMALTUPLE(slot)
Definition: tuptable.h:230
ERROR
#define ERROR
Definition: elog.h:43
tts_minimal_store_tuple
static void tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
Definition: execTuples.c:599
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Assert
#define Assert(condition)
Definition: c.h:746
elog
#define elog(elevel,...)
Definition: elog.h:214
unlikely
#define unlikely(x)
Definition: c.h:207

◆ ExecStorePinnedBufferHeapTuple()

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

Definition at line 1388 of file execTuples.c.

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().

1391 {
1392  /*
1393  * sanity checks
1394  */
1395  Assert(tuple != NULL);
1396  Assert(slot != NULL);
1397  Assert(slot->tts_tupleDescriptor != NULL);
1398  Assert(BufferIsValid(buffer));
1399 
1400  if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1401  elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1402  tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
1403 
1404  slot->tts_tableOid = tuple->t_tableOid;
1405 
1406  return slot;
1407 }
TupleTableSlot::tts_tableOid
Oid tts_tableOid
Definition: tuptable.h:131
tts_buffer_heap_store_tuple
static void tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
Definition: execTuples.c:829
ERROR
#define ERROR
Definition: elog.h:43
HeapTupleData::t_tableOid
Oid t_tableOid
Definition: htup.h:66
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
TTS_IS_BUFFERTUPLE
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:231
Assert
#define Assert(condition)
Definition: c.h:746
BufferIsValid
#define BufferIsValid(bufnum)
Definition: bufmgr.h:123
elog
#define elog(elevel,...)
Definition: elog.h:214
unlikely
#define unlikely(x)
Definition: c.h:207

◆ ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot *  slot)

Definition at line 1522 of file execTuples.c.

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(), do_tup_output(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hashagg_spill_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), InsertPgAttributeTuples(), ordered_set_transition_multi(), prepare_hash_slot(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_data(), slot_store_data(), StoreIndexTuple(), and ValuesNext().

1523 {
1524  /*
1525  * sanity checks
1526  */
1527  Assert(slot != NULL);
1528  Assert(slot->tts_tupleDescriptor != NULL);
1529  Assert(TTS_EMPTY(slot));
1530 
1531  slot->tts_flags &= ~TTS_FLAG_EMPTY;
1532  slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
1533 
1534  return slot;
1535 }
TTS_FLAG_EMPTY
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
TTS_EMPTY
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
TupleTableSlot::tts_flags
uint16 tts_flags
Definition: tuptable.h:119
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Assert
#define Assert(condition)
Definition: c.h:746
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ MakeSingleTupleTableSlot()

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

Definition at line 1208 of file execTuples.c.

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTableExt(), CatalogIndexInsert(), compute_index_stats(), copyTemplateDependencies(), ExecInitIncrementalSort(), ExecInitJunkFilterConversion(), ExecInitJunkFilterInsertion(), ExecInitPartitionDispatchInfo(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), heapam_index_validate_scan(), hypothetical_dense_rank_final(), init_sql_fcache(), InsertPgAttributeTuples(), ordered_set_startup(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), RunFromStore(), table_slot_create(), tstoreStartupReceiver(), and tuplesort_begin_cluster().

1210 {
1211  TupleTableSlot *slot = MakeTupleTableSlot(tupdesc, tts_ops);
1212 
1213  return slot;
1214 }
MakeTupleTableSlot
TupleTableSlot * MakeTupleTableSlot(TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1082

◆ MakeTupleTableSlot()

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

Definition at line 1082 of file execTuples.c.

References TupleTableSlotOps::base_slot_size, CurrentMemoryContext, TupleTableSlotOps::init, MAXALIGN, TupleDescData::natts, palloc0(), PinTupleDesc, T_TupleTableSlot, 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(), and MakeSingleTupleTableSlot().

1084 {
1085  Size basesz,
1086  allocsz;
1087  TupleTableSlot *slot;
1088 
1089  basesz = tts_ops->base_slot_size;
1090 
1091  /*
1092  * When a fixed descriptor is specified, we can reduce overhead by
1093  * allocating the entire slot in one go.
1094  */
1095  if (tupleDesc)
1096  allocsz = MAXALIGN(basesz) +
1097  MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
1098  MAXALIGN(tupleDesc->natts * sizeof(bool));
1099  else
1100  allocsz = basesz;
1101 
1102  slot = palloc0(allocsz);
1103  /* const for optimization purposes, OK to modify at allocation time */
1104  *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
1105  slot->type = T_TupleTableSlot;
1106  slot->tts_flags |= TTS_FLAG_EMPTY;
1107  if (tupleDesc != NULL)
1108  slot->tts_flags |= TTS_FLAG_FIXED;
1109  slot->tts_tupleDescriptor = tupleDesc;
1110  slot->tts_mcxt = CurrentMemoryContext;
1111  slot->tts_nvalid = 0;
1112 
1113  if (tupleDesc != NULL)
1114  {
1115  slot->tts_values = (Datum *)
1116  (((char *) slot)
1117  + MAXALIGN(basesz));
1118  slot->tts_isnull = (bool *)
1119  (((char *) slot)
1120  + MAXALIGN(basesz)
1121  + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
1122 
1123  PinTupleDesc(tupleDesc);
1124  }
1125 
1126  /*
1127  * And allow slot type specific initialization.
1128  */
1129  slot->tts_ops->init(slot);
1130 
1131  return slot;
1132 }
TTS_FLAG_EMPTY
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
TupleTableSlot::tts_mcxt
MemoryContext tts_mcxt
Definition: tuptable.h:129
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot::type
NodeTag type
Definition: tuptable.h:117
TupleTableSlot::tts_flags
uint16 tts_flags
Definition: tuptable.h:119
TupleTableSlotOps::init
void(* init)(TupleTableSlot *slot)
Definition: tuptable.h:141
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
CurrentMemoryContext
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
palloc0
void * palloc0(Size size)
Definition: mcxt.c:981
Datum
uintptr_t Datum
Definition: postgres.h:367
TTS_FLAG_FIXED
#define TTS_FLAG_FIXED
Definition: tuptable.h:108
Size
size_t Size
Definition: c.h:474
MAXALIGN
#define MAXALIGN(LEN)
Definition: c.h:699
PinTupleDesc
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121
TupleTableSlotOps::base_slot_size
size_t base_slot_size
Definition: tuptable.h:138

◆ slot_attisnull()

static bool slot_attisnull ( TupleTableSlot *  slot,
int  attnum 
)
inlinestatic

Definition at line 367 of file tuptable.h.

References AssertArg, slot_getsomeattrs(), TupleTableSlot::tts_isnull, and TupleTableSlot::tts_nvalid.

Referenced by AlterDomainNotNull(), ATRewriteTable(), ExecConstraints(), ri_NullCheck(), slotAllNulls(), and slotNoNulls().

368 {
369  AssertArg(attnum > 0);
370 
371  if (attnum > slot->tts_nvalid)
372  slot_getsomeattrs(slot, attnum);
373 
374  return slot->tts_isnull[attnum - 1];
375 }
slot_getsomeattrs
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:341
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
AssertArg
#define AssertArg(condition)
Definition: c.h:748
attnum
int16 attnum
Definition: pg_attribute.h:79
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ slot_getallattrs()

static void slot_getallattrs ( TupleTableSlot *  slot)
inlinestatic

Definition at line 354 of file tuptable.h.

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(), CopyTo(), ExecBuildSlotValueDescription(), ExecComputeStoredGenerated(), ExecEvalWholeRowVar(), ExecFilterJunk(), execute_attr_map_slot(), FunctionNext(), printsimple(), printtup(), printtup_20(), printtup_internal_20(), slot_modify_data(), tstoreReceiveSlot_detoast(), tts_virtual_copyslot(), and tuples_equal().

355 {
356  slot_getsomeattrs(slot, slot->tts_tupleDescriptor->natts);
357 }
slot_getsomeattrs
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:341
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124

◆ slot_getattr()

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

Definition at line 381 of file tuptable.h.

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

Referenced by buildSubPlanHash(), 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(), TupleHashTableHash_internal(), update_frameheadpos(), update_frametailpos(), and validateDomainConstraint().

383 {
384  AssertArg(attnum > 0);
385 
386  if (attnum > slot->tts_nvalid)
387  slot_getsomeattrs(slot, attnum);
388 
389  *isnull = slot->tts_isnull[attnum - 1];
390 
391  return slot->tts_values[attnum - 1];
392 }
slot_getsomeattrs
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:341
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
AssertArg
#define AssertArg(condition)
Definition: c.h:748
attnum
int16 attnum
Definition: pg_attribute.h:79
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ slot_getmissingattrs()

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

Definition at line 1838 of file execTuples.c.

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().

1839 {
1840  AttrMissing *attrmiss = NULL;
1841 
1842  if (slot->tts_tupleDescriptor->constr)
1843  attrmiss = slot->tts_tupleDescriptor->constr->missing;
1844 
1845  if (!attrmiss)
1846  {
1847  /* no missing values array at all, so just fill everything in as NULL */
1848  memset(slot->tts_values + startAttNum, 0,
1849  (lastAttNum - startAttNum) * sizeof(Datum));
1850  memset(slot->tts_isnull + startAttNum, 1,
1851  (lastAttNum - startAttNum) * sizeof(bool));
1852  }
1853  else
1854  {
1855  int missattnum;
1856 
1857  /* if there is a missing values array we must process them one by one */
1858  for (missattnum = startAttNum;
1859  missattnum < lastAttNum;
1860  missattnum++)
1861  {
1862  slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
1863  slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
1864  }
1865  }
1866 }
TupleTableSlot::tts_values
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot::tts_isnull
bool * tts_isnull
Definition: tuptable.h:128
TupleDescData::constr
TupleConstr * constr
Definition: tupdesc.h:85
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
Datum
uintptr_t Datum
Definition: postgres.h:367
TupleConstr::missing
struct AttrMissing * missing
Definition: tupdesc.h:41

◆ slot_getsomeattrs()

static void slot_getsomeattrs ( TupleTableSlot *  slot,
int  attnum 
)
inlinestatic

Definition at line 341 of file tuptable.h.

References slot_getsomeattrs_int(), and TupleTableSlot::tts_nvalid.

Referenced by ExecInterpExpr(), hashagg_spill_tuple(), prepare_hash_slot(), prepare_projection_slot(), process_ordered_aggregate_multi(), slot_attisnull(), slot_getallattrs(), and slot_getattr().

342 {
343  if (slot->tts_nvalid < attnum)
344  slot_getsomeattrs_int(slot, attnum);
345 }
attnum
int16 attnum
Definition: pg_attribute.h:79
slot_getsomeattrs_int
void slot_getsomeattrs_int(TupleTableSlot *slot, int attnum)
Definition: execTuples.c:1872
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ slot_getsomeattrs_int()

void slot_getsomeattrs_int ( TupleTableSlot *  slot,
int  attnum 
)

Definition at line 1872 of file execTuples.c.

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().

1873 {
1874  /* Check for caller errors */
1875  Assert(slot->tts_nvalid < attnum); /* checked in slot_getsomeattrs */
1876  Assert(attnum > 0);
1877 
1878  if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
1879  elog(ERROR, "invalid attribute number %d", attnum);
1880 
1881  /* Fetch as many attributes as possible from the underlying tuple. */
1882  slot->tts_ops->getsomeattrs(slot, attnum);
1883 
1884  /*
1885  * If the underlying tuple doesn't have enough attributes, tuple
1886  * descriptor must have the missing attributes.
1887  */
1888  if (unlikely(slot->tts_nvalid < attnum))
1889  {
1890  slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
1891  slot->tts_nvalid = attnum;
1892  }
1893 }
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
ERROR
#define ERROR
Definition: elog.h:43
TupleTableSlot::tts_tupleDescriptor
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
attnum
int16 attnum
Definition: pg_attribute.h:79
Assert
#define Assert(condition)
Definition: c.h:746
TupleTableSlotOps::getsomeattrs
void(* getsomeattrs)(TupleTableSlot *slot, int natts)
Definition: tuptable.h:161
slot_getmissingattrs
void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
Definition: execTuples.c:1838
elog
#define elog(elevel,...)
Definition: elog.h:214
unlikely
#define unlikely(x)
Definition: c.h:207
TupleTableSlot::tts_nvalid
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ slot_getsysattr()

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

Definition at line 402 of file tuptable.h.

References AssertArg, TupleTableSlotOps::getsysattr, ObjectIdGetDatum, PointerGetDatum, SelfItemPointerAttributeNumber, TableOidAttributeNumber, TupleTableSlot::tts_ops, TupleTableSlot::tts_tableOid, and TupleTableSlot::tts_tid.

Referenced by ExecCheckTupleVisible(), execCurrentOf(), ExecEvalSysVar(), ExecOnConflictUpdate(), FormIndexDatum(), and RI_FKey_fk_upd_check_required().

403 {
404  AssertArg(attnum < 0); /* caller error */
405 
406  if (attnum == TableOidAttributeNumber)
407  {
408  *isnull = false;
409  return ObjectIdGetDatum(slot->tts_tableOid);
410  }
411  else if (attnum == SelfItemPointerAttributeNumber)
412  {
413  *isnull = false;
414  return PointerGetDatum(&slot->tts_tid);
415  }
416 
417  /* Fetch the system attribute from the underlying tuple. */
418  return slot->tts_ops->getsysattr(slot, attnum, isnull);
419 }
TupleTableSlot::tts_tableOid
Oid tts_tableOid
Definition: tuptable.h:131
TupleTableSlotOps::getsysattr
Datum(* getsysattr)(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:168
PointerGetDatum
#define PointerGetDatum(X)
Definition: postgres.h:556
TupleTableSlot::tts_ops
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
ObjectIdGetDatum
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
TableOidAttributeNumber
#define TableOidAttributeNumber
Definition: sysattr.h:26
AssertArg
#define AssertArg(condition)
Definition: c.h:748
attnum
int16 attnum
Definition: pg_attribute.h:79
SelfItemPointerAttributeNumber
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21
TupleTableSlot::tts_tid
ItemPointerData tts_tid
Definition: tuptable.h:130

Variable Documentation

◆ TTSOpsBufferHeapTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsBufferHeapTuple

Definition at line 86 of file execTuples.c.

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

◆ TTSOpsHeapTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsHeapTuple

Definition at line 84 of file execTuples.c.

Referenced by CatalogIndexInsert(), CheckOpSlotCompatibility(), compute_index_stats(), copyTemplateDependencies(), ExecInitForeignScan(), ExecInitSetOp(), ExecuteCallStmt(), heapam_index_validate_scan(), InsertPgAttributeTuples(), recordMultipleDependencies(), slot_compile_deform(), table_slot_callbacks(), and tuplesort_begin_cluster().

◆ TTSOpsMinimalTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsMinimalTuple

Definition at line 85 of file execTuples.c.

Referenced by afterTriggerInvokeEvents(), build_pertrans_for_aggref(), BuildTupleHashTableExt(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHash(), ExecInitIncrementalSort(), ExecInitMaterial(), 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(), and slot_compile_deform().

◆ TTSOpsVirtual

PGDLLIMPORT const TupleTableSlotOps TTSOpsVirtual

Definition at line 83 of file execTuples.c.

Referenced by AfterTriggerSaveEvent(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), CheckOpSlotCompatibility(), CreateReplicationSlot(), ExecComputeSlotInfo(), ExecConditionalAssignProjectionInfo(), ExecConstraints(), ExecGetResultSlotOps(), ExecInitAgg(), ExecInitAppend(), ExecInitCustomScan(), ExecInitGroup(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitJunkFilterConversion(), ExecInitJunkFilterInsertion(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitProjectSet(), ExecInitResult(), ExecInitSort(), ExecInitSubPlan(), ExecInitValuesScan(), ExecInitWholeRowVar(), ExecInitWindowAgg(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), ExplainQuery(), IdentifySystem(), InitPlan(), llvm_compile_expr(), RI_Initial_Check(), RI_PartitionRemove_Check(), ShowAllGUCConfig(), ShowGUCConfigOption(), slot_compile_deform(), StartReplication(), table_slot_callbacks(), and tstoreStartupReceiver().