PostgreSQL Source Code  git master
tuptable.h File Reference
#include "access/htup.h"
#include "access/sysattr.h"
#include "access/tupdesc.h"
#include "access/htup_details.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

TupleTableSlotMakeTupleTableSlot (TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
 
TupleTableSlotExecAllocTableSlot (List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
 
void ExecResetTupleTable (List *tupleTable, bool shouldFree)
 
TupleTableSlotMakeSingleTupleTableSlot (TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
 
void ExecDropSingleTupleTableSlot (TupleTableSlot *slot)
 
void ExecSetSlotDescriptor (TupleTableSlot *slot, TupleDesc tupdesc)
 
TupleTableSlotExecStoreHeapTuple (HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
 
void ExecForceStoreHeapTuple (HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
 
TupleTableSlotExecStoreBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
 
TupleTableSlotExecStorePinnedBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
 
TupleTableSlotExecStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
 
void ExecForceStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
 
TupleTableSlotExecStoreVirtualTuple (TupleTableSlot *slot)
 
TupleTableSlotExecStoreAllNullTuple (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 TupleTableSlotExecClearTuple (TupleTableSlot *slot)
 
static void ExecMaterializeSlot (TupleTableSlot *slot)
 
static HeapTuple ExecCopySlotHeapTuple (TupleTableSlot *slot)
 
static MinimalTuple ExecCopySlotMinimalTuple (TupleTableSlot *slot)
 
static TupleTableSlotExecCopySlot (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

◆ TTS_FIXED

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

◆ TTS_FLAG_EMPTY

◆ TTS_FLAG_FIXED

#define TTS_FLAG_FIXED   (1 << 4)

Definition at line 108 of file tuptable.h.

Referenced by MakeTupleTableSlot().

◆ TTS_FLAG_SHOULDFREE

◆ 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

◆ 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

◆ 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

Typedef Documentation

◆ BufferHeapTupleTableSlot

◆ HeapTupleTableSlot

◆ MinimalTupleTableSlot

◆ TupleTableSlot

◆ TupleTableSlotOps

Definition at line 112 of file tuptable.h.

◆ 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 }
List * lappend(List *list, void *datum)
Definition: list.c:322
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(), apply_handle_update(), apply_returning_filter(), ATRewriteTable(), begin_partition(), BitmapHeapNext(), buildSubPlanHash(), CopyFrom(), CopyMultiInsertBufferFlush(), CteScanNext(), do_tup_output(), eval_windowaggregates(), EvalPlanQual(), ExecAppend(), ExecARUpdateTriggers(), ExecCheckTIDVisible(), ExecComputeStoredGenerated(), ExecDelete(), ExecDropSingleTupleTableSlot(), ExecEndAgg(), ExecEndBitmapHeapScan(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHashJoin(), 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(), ExecLockRows(), ExecMaterial(), ExecMergeAppend(), ExecOnConflictUpdate(), ExecParallelHashJoinOuterGetTuple(), ExecProject(), ExecProjectSRF(), ExecReScanAgg(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanGroup(), 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(), heap_getnextslot(), heapam_scan_analyze_next_tuple(), heapam_scan_sample_next_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), lookup_hash_entry(), ordered_set_shutdown(), ordered_set_transition_multi(), postgresIterateDirectModify(), postgresIterateForeignScan(), process_ordered_aggregate_multi(), RunFromStore(), setop_retrieve_direct(), setop_retrieve_hash_table(), ShutdownSetExpr(), slot_modify_cstrings(), slot_store_cstrings(), StoreIndexTuple(), 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 }
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
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_update(), begin_partition(), CopyFrom(), CteScanNext(), EvalPlanQual(), ExecBRUpdateTriggers(), ExecGroup(), ExecMaterial(), ExecModifyTable(), ExecUnique(), ExecWindowAgg(), postgresRecheckForeignScan(), RelationFindReplTupleSeq(), spool_tuples(), 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 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
#define AssertArg(condition)
Definition: c.h:735
#define Assert(condition)
Definition: c.h:733
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 }
HeapTuple(* copy_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:206
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
#define Assert(condition)
Definition: c.h:733

◆ 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(), tts_minimal_copyslot(), and tuplestore_puttupleslot().

464 {
465  return slot->tts_ops->copy_minimal_tuple(slot);
466 }
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
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(), CopyTo(), DefineQueryRewrite(), end_tup_output(), ExecCleanupTupleRouting(), 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(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tuplesort_end(), unique_key_recheck(), validateCheckConstraint(), 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)
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 }
#define TTS_FIXED(slot)
Definition: tuptable.h:109
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
void(* release)(TupleTableSlot *slot)
Definition: tuptable.h:144
Datum * tts_values
Definition: tuptable.h:126
void pfree(void *pointer)
Definition: mcxt.c:1056
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:733
#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(), 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(), tqueueReceiveSlot(), 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 }
HeapTuple(* copy_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:206
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
HeapTuple(* get_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:188
#define Assert(condition)
Definition: c.h:733
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 }
void pfree(void *pointer)
Definition: mcxt.c:1056
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition: execTuples.c:1614
Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
Definition: heaptuple.c:984
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
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(), and ExecParallelHashTableInsertCurrentBatch().

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 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
MinimalTuple(* get_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:196
MinimalTuple(* copy_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:216
#define Assert(condition)
Definition: c.h:733

◆ 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;
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);
1466  slot->tts_values, slot->tts_isnull);
1467  ExecStoreVirtualTuple(slot);
1468 
1469  if (shouldFree)
1470  {
1471  ExecMaterializeSlot(slot);
1472  pfree(tuple);
1473  }
1474  }
1475 }
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
HeapTuple tuple
Definition: tuptable.h:250
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
uint16 tts_flags
Definition: tuptable.h:119
void pfree(void *pointer)
Definition: mcxt.c:1056
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:231
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:443
#define TTS_IS_HEAPTUPLE(slot)
Definition: tuptable.h:229
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
HeapTupleTableSlot base
Definition: tuptable.h:259
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition: execTuples.c:1322
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);
1499  slot->tts_values, slot->tts_isnull);
1500  ExecStoreVirtualTuple(slot);
1501 
1502  if (shouldFree)
1503  {
1504  ExecMaterializeSlot(slot);
1505  pfree(mtup);
1506  }
1507  }
1508 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define TTS_IS_MINIMALTUPLE(slot)
Definition: tuptable.h:230
Datum * tts_values
Definition: tuptable.h:126
HeapTupleHeader t_data
Definition: htup.h:68
void pfree(void *pointer)
Definition: mcxt.c:1056
uint32 t_len
Definition: htup.h:64
bool * tts_isnull
Definition: tuptable.h:128
static void tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
Definition: execTuples.c:599
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:443
#define MINIMAL_TUPLE_OFFSET
Definition: htup_details.h:619
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522

◆ ExecMaterializeSlot()

static void ExecMaterializeSlot ( TupleTableSlot slot)
inlinestatic

◆ 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  {
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  {
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 }
#define TTS_FIXED(slot)
Definition: tuptable.h:109
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
void(* release)(TupleTableSlot *slot)
Definition: tuptable.h:144
Datum * tts_values
Definition: tuptable.h:126
void pfree(void *pointer)
Definition: mcxt.c:1056
#define lfirst_node(type, lc)
Definition: pg_list.h:193
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
void list_free(List *list)
Definition: list.c:1377
#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(), ExecInitJunkFilter(), and ExecInitJunkFilterConversion().

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)
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 }
#define TTS_FIXED(slot)
Definition: tuptable.h:109
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
void pfree(void *pointer)
Definition: mcxt.c:1056
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uintptr_t Datum
Definition: postgres.h:367
#define Assert(condition)
Definition: c.h:733
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
#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 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
#define MemSet(start, val, len)
Definition: c.h:956
Datum * tts_values
Definition: tuptable.h:126
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uintptr_t Datum
Definition: postgres.h:367
#define Assert(condition)
Definition: c.h:733
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 }
Oid tts_tableOid
Definition: tuptable.h:131
static void tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
Definition: execTuples.c:829
#define ERROR
Definition: elog.h:43
Oid t_tableOid
Definition: htup.h:66
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:231
#define Assert(condition)
Definition: c.h:733
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
#define elog(elevel,...)
Definition: elog.h:228
#define unlikely(x)
Definition: c.h:208

◆ 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(), gather_getnext(), gather_merge_readnext(), 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 }
Oid tts_tableOid
Definition: tuptable.h:131
#define ERROR
Definition: elog.h:43
Oid t_tableOid
Definition: htup.h:66
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define TTS_IS_HEAPTUPLE(slot)
Definition: tuptable.h:229
#define Assert(condition)
Definition: c.h:733
#define elog(elevel,...)
Definition: elog.h:228
static void tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
Definition: execTuples.c:431
#define unlikely(x)
Definition: c.h:208

◆ 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 
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 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
Datum * tts_values
Definition: tuptable.h:126
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:289
HeapTupleHeader t_data
Definition: htup.h:68
ItemPointerData t_ctid
Definition: htup_details.h:160
ItemPointerData t_self
Definition: htup.h:65
uint32 t_len
Definition: htup.h:64
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1249
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522
#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_retrieve_hash_table(), ExecParallelScanHashBucket(), ExecScanHashBucket(), ExecScanHashTableForUnmatched(), findPartialMatch(), setop_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash(), 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 }
#define TTS_IS_MINIMALTUPLE(slot)
Definition: tuptable.h:230
#define ERROR
Definition: elog.h:43
static void tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
Definition: execTuples.c:599
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:733
#define elog(elevel,...)
Definition: elog.h:228
#define unlikely(x)
Definition: c.h:208

◆ 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 }
Oid tts_tableOid
Definition: tuptable.h:131
static void tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
Definition: execTuples.c:829
#define ERROR
Definition: elog.h:43
Oid t_tableOid
Definition: htup.h:66
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:231
#define Assert(condition)
Definition: c.h:733
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
#define elog(elevel,...)
Definition: elog.h:228
#define unlikely(x)
Definition: c.h:208

◆ 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(), apply_returning_filter(), ATRewriteTable(), CopyFrom(), do_tup_output(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hypothetical_dense_rank_final(), hypothetical_rank_common(), lookup_hash_entry(), ordered_set_transition_multi(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_cstrings(), slot_store_cstrings(), 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 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
uint16 tts_flags
Definition: tuptable.h:119
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:733
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ MakeSingleTupleTableSlot()

◆ 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;
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 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
NodeTag type
Definition: tuptable.h:117
uint16 tts_flags
Definition: tuptable.h:119
void(* init)(TupleTableSlot *slot)
Definition: tuptable.h:141
bool * tts_isnull
Definition: tuptable.h:128
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
void * palloc0(Size size)
Definition: mcxt.c:980
uintptr_t Datum
Definition: postgres.h:367
#define TTS_FLAG_FIXED
Definition: tuptable.h:108
size_t Size
Definition: c.h:467
#define MAXALIGN(LEN)
Definition: c.h:686
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116
AttrNumber tts_nvalid
Definition: tuptable.h:121
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 }
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:341
bool * tts_isnull
Definition: tuptable.h:128
#define AssertArg(condition)
Definition: c.h:735
int16 attnum
Definition: pg_attribute.h:79
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ slot_getallattrs()

◆ slot_getattr()

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

◆ 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 }
Datum * tts_values
Definition: tuptable.h:126
bool * tts_isnull
Definition: tuptable.h:128
TupleConstr * constr
Definition: tupdesc.h:85
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uintptr_t Datum
Definition: postgres.h:367
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(), lookup_hash_entry(), prepare_projection_slot(), process_ordered_aggregate_multi(), slot_attisnull(), slot_getallattrs(), and slot_getattr().

342 {
343  if (slot->tts_nvalid < attnum)
345 }
int16 attnum
Definition: pg_attribute.h:79
void slot_getsomeattrs_int(TupleTableSlot *slot, int attnum)
Definition: execTuples.c:1872
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 }
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
#define ERROR
Definition: elog.h:43
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
int16 attnum
Definition: pg_attribute.h:79
#define Assert(condition)
Definition: c.h:733
void(* getsomeattrs)(TupleTableSlot *slot, int natts)
Definition: tuptable.h:161
void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
Definition: execTuples.c:1838
#define elog(elevel,...)
Definition: elog.h:228
#define unlikely(x)
Definition: c.h:208
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 
407  {
408  *isnull = false;
409  return ObjectIdGetDatum(slot->tts_tableOid);
410  }
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 }
Oid tts_tableOid
Definition: tuptable.h:131
Datum(* getsysattr)(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:168
#define PointerGetDatum(X)
Definition: postgres.h:556
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define TableOidAttributeNumber
Definition: sysattr.h:26
#define AssertArg(condition)
Definition: c.h:735
int16 attnum
Definition: pg_attribute.h:79
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21
ItemPointerData tts_tid
Definition: tuptable.h:130

Variable Documentation

◆ TTSOpsBufferHeapTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsBufferHeapTuple

◆ TTSOpsHeapTuple

◆ TTSOpsMinimalTuple

◆ TTSOpsVirtual