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

Referenced by slot_compile_deform().

◆ FIELDNO_MINIMALTUPLETABLESLOT_TUPLE

#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1

Definition at line 282 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.

◆ 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 1135 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

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

1137 {
1138  TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);
1139 
1140  *tupleTable = lappend(*tupleTable, slot);
1141 
1142  return slot;
1143 }
List * lappend(List *list, void *datum)
Definition: list.c:321
TupleTableSlot * MakeTupleTableSlot(TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1076

◆ ExecClearTuple()

static TupleTableSlot* ExecClearTuple ( TupleTableSlot slot)
inlinestatic

Definition at line 426 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(), EvalPlanQualFetchRowMarks(), 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().

427 {
428  slot->tts_ops->clear(slot);
429 
430  return slot;
431 }
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 476 of file tuptable.h.

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

477 {
478  Assert(!TTS_EMPTY(srcslot));
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 Assert(condition)
Definition: c.h:732
void(* copyslot)(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: tuptable.h:180

◆ ExecCopySlotHeapTuple()

static HeapTuple ExecCopySlotHeapTuple ( TupleTableSlot slot)
inlinestatic

Definition at line 453 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().

454 {
455  Assert(!TTS_EMPTY(slot));
456 
457  return slot->tts_ops->copy_heap_tuple(slot);
458 }
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:732

◆ ExecCopySlotMinimalTuple()

static MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot slot)
inlinestatic

Definition at line 464 of file tuptable.h.

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

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

465 {
466  return slot->tts_ops->copy_minimal_tuple(slot);
467 }
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 1218 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().

1219 {
1220  /* This should match ExecResetTupleTable's processing of one slot */
1221  Assert(IsA(slot, TupleTableSlot));
1222  ExecClearTuple(slot);
1223  slot->tts_ops->release(slot);
1224  if (slot->tts_tupleDescriptor)
1226  if (!TTS_FIXED(slot))
1227  {
1228  if (slot->tts_values)
1229  pfree(slot->tts_values);
1230  if (slot->tts_isnull)
1231  pfree(slot->tts_isnull);
1232  }
1233  pfree(slot);
1234 }
#define TTS_FIXED(slot)
Definition: tuptable.h:109
#define IsA(nodeptr, _type_)
Definition: nodes.h:575
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
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:1031
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:732
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122

◆ ExecFetchSlotHeapTuple()

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

Definition at line 1608 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().

1609 {
1610  /*
1611  * sanity checks
1612  */
1613  Assert(slot != NULL);
1614  Assert(!TTS_EMPTY(slot));
1615 
1616  /* Materialize the tuple so that the slot "owns" it, if requested. */
1617  if (materialize)
1618  slot->tts_ops->materialize(slot);
1619 
1620  if (slot->tts_ops->get_heap_tuple == NULL)
1621  {
1622  if (shouldFree)
1623  *shouldFree = true;
1624  return slot->tts_ops->copy_heap_tuple(slot);
1625  }
1626  else
1627  {
1628  if (shouldFree)
1629  *shouldFree = false;
1630  return slot->tts_ops->get_heap_tuple(slot);
1631  }
1632 }
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:732
void(* materialize)(TupleTableSlot *slot)
Definition: tuptable.h:174

◆ ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum ( TupleTableSlot slot)

Definition at line 1687 of file execTuples.c.

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

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

1688 {
1689  HeapTuple tup;
1690  TupleDesc tupdesc;
1691  bool shouldFree;
1692  Datum ret;
1693 
1694  /* Fetch slot's contents in regular-physical-tuple form */
1695  tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
1696  tupdesc = slot->tts_tupleDescriptor;
1697 
1698  /* Convert to Datum form */
1699  ret = heap_copy_tuple_as_datum(tup, tupdesc);
1700 
1701  if (shouldFree)
1702  pfree(tup);
1703 
1704  return ret;
1705 }
void pfree(void *pointer)
Definition: mcxt.c:1031
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition: execTuples.c:1608
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 1656 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().

1658 {
1659  /*
1660  * sanity checks
1661  */
1662  Assert(slot != NULL);
1663  Assert(!TTS_EMPTY(slot));
1664 
1665  if (slot->tts_ops->get_minimal_tuple)
1666  {
1667  if (shouldFree)
1668  *shouldFree = false;
1669  return slot->tts_ops->get_minimal_tuple(slot);
1670  }
1671  else
1672  {
1673  if (shouldFree)
1674  *shouldFree = true;
1675  return slot->tts_ops->copy_minimal_tuple(slot);
1676  }
1677 }
#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:732

◆ ExecForceStoreHeapTuple()

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

Definition at line 1433 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().

1436 {
1437  if (TTS_IS_HEAPTUPLE(slot))
1438  {
1439  ExecStoreHeapTuple(tuple, slot, shouldFree);
1440  }
1441  else if (TTS_IS_BUFFERTUPLE(slot))
1442  {
1443  MemoryContext oldContext;
1445 
1446  ExecClearTuple(slot);
1447  slot->tts_flags |= TTS_FLAG_SHOULDFREE;
1448  slot->tts_flags &= ~TTS_FLAG_EMPTY;
1449  oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
1450  bslot->base.tuple = heap_copytuple(tuple);
1451  MemoryContextSwitchTo(oldContext);
1452 
1453  if (shouldFree)
1454  pfree(tuple);
1455  }
1456  else
1457  {
1458  ExecClearTuple(slot);
1460  slot->tts_values, slot->tts_isnull);
1461  ExecStoreVirtualTuple(slot);
1462 
1463  if (shouldFree)
1464  {
1465  ExecMaterializeSlot(slot);
1466  pfree(tuple);
1467  }
1468  }
1469 }
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:426
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:1031
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:444
#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:1316
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1516

◆ ExecForceStoreMinimalTuple()

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

Definition at line 1476 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().

1479 {
1480  if (TTS_IS_MINIMALTUPLE(slot))
1481  {
1482  tts_minimal_store_tuple(slot, mtup, shouldFree);
1483  }
1484  else
1485  {
1486  HeapTupleData htup;
1487 
1488  ExecClearTuple(slot);
1489 
1490  htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
1491  htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
1493  slot->tts_values, slot->tts_isnull);
1494  ExecStoreVirtualTuple(slot);
1495 
1496  if (shouldFree)
1497  {
1498  ExecMaterializeSlot(slot);
1499  pfree(mtup);
1500  }
1501  }
1502 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
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:1031
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:597
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:444
#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:1516

◆ ExecMaterializeSlot()

static void ExecMaterializeSlot ( TupleTableSlot slot)
inlinestatic

◆ ExecResetTupleTable()

void ExecResetTupleTable ( List tupleTable,
bool  shouldFree 
)

Definition at line 1155 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().

1157 {
1158  ListCell *lc;
1159 
1160  foreach(lc, tupleTable)
1161  {
1163 
1164  /* Always release resources and reset the slot to empty */
1165  ExecClearTuple(slot);
1166  slot->tts_ops->release(slot);
1167  if (slot->tts_tupleDescriptor)
1168  {
1170  slot->tts_tupleDescriptor = NULL;
1171  }
1172 
1173  /* If shouldFree, release memory occupied by the slot itself */
1174  if (shouldFree)
1175  {
1176  if (!TTS_FIXED(slot))
1177  {
1178  if (slot->tts_values)
1179  pfree(slot->tts_values);
1180  if (slot->tts_isnull)
1181  pfree(slot->tts_isnull);
1182  }
1183  pfree(slot);
1184  }
1185  }
1186 
1187  /* If shouldFree, release the list structure */
1188  if (shouldFree)
1189  list_free(tupleTable);
1190 }
#define TTS_FIXED(slot)
Definition: tuptable.h:109
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
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:1031
#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:1330
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122

◆ ExecSetSlotDescriptor()

void ExecSetSlotDescriptor ( TupleTableSlot slot,
TupleDesc  tupdesc 
)

Definition at line 1253 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().

1255 {
1256  Assert(!TTS_FIXED(slot));
1257 
1258  /* For safety, make sure slot is empty before changing it */
1259  ExecClearTuple(slot);
1260 
1261  /*
1262  * Release any old descriptor. Also release old Datum/isnull arrays if
1263  * present (we don't bother to check if they could be re-used).
1264  */
1265  if (slot->tts_tupleDescriptor)
1267 
1268  if (slot->tts_values)
1269  pfree(slot->tts_values);
1270  if (slot->tts_isnull)
1271  pfree(slot->tts_isnull);
1272 
1273  /*
1274  * Install the new descriptor; if it's refcounted, bump its refcount.
1275  */
1276  slot->tts_tupleDescriptor = tupdesc;
1277  PinTupleDesc(tupdesc);
1278 
1279  /*
1280  * Allocate Datum/isnull arrays of the appropriate size. These must have
1281  * the same lifetime as the slot, so allocate in the slot's own context.
1282  */
1283  slot->tts_values = (Datum *)
1284  MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
1285  slot->tts_isnull = (bool *)
1286  MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
1287 }
#define TTS_FIXED(slot)
Definition: tuptable.h:109
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
void pfree(void *pointer)
Definition: mcxt.c:1031
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:732
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:771
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122

◆ ExecStoreAllNullTuple()

TupleTableSlot* ExecStoreAllNullTuple ( TupleTableSlot slot)

Definition at line 1540 of file execTuples.c.

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

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

1541 {
1542  /*
1543  * sanity checks
1544  */
1545  Assert(slot != NULL);
1546  Assert(slot->tts_tupleDescriptor != NULL);
1547 
1548  /* Clear any old contents */
1549  ExecClearTuple(slot);
1550 
1551  /*
1552  * Fill all the columns of the virtual tuple with nulls
1553  */
1554  MemSet(slot->tts_values, 0,
1555  slot->tts_tupleDescriptor->natts * sizeof(Datum));
1556  memset(slot->tts_isnull, true,
1557  slot->tts_tupleDescriptor->natts * sizeof(bool));
1558 
1559  return ExecStoreVirtualTuple(slot);
1560 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
#define MemSet(start, val, len)
Definition: c.h:941
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:732
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1516

◆ ExecStoreBufferHeapTuple()

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

Definition at line 1356 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().

1359 {
1360  /*
1361  * sanity checks
1362  */
1363  Assert(tuple != NULL);
1364  Assert(slot != NULL);
1365  Assert(slot->tts_tupleDescriptor != NULL);
1366  Assert(BufferIsValid(buffer));
1367 
1368  if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1369  elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1370  tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
1371 
1372  slot->tts_tableOid = tuple->t_tableOid;
1373 
1374  return slot;
1375 }
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:823
#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:732
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
#define elog(elevel,...)
Definition: elog.h:226
#define unlikely(x)
Definition: c.h:208

◆ ExecStoreHeapTuple()

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

Definition at line 1316 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().

1319 {
1320  /*
1321  * sanity checks
1322  */
1323  Assert(tuple != NULL);
1324  Assert(slot != NULL);
1325  Assert(slot->tts_tupleDescriptor != NULL);
1326 
1327  if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
1328  elog(ERROR, "trying to store a heap tuple into wrong type of slot");
1329  tts_heap_store_tuple(slot, tuple, shouldFree);
1330 
1331  slot->tts_tableOid = tuple->t_tableOid;
1332 
1333  return slot;
1334 }
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:732
#define elog(elevel,...)
Definition: elog.h:226
static void tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
Definition: execTuples.c:430
#define unlikely(x)
Definition: c.h:208

◆ ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data,
TupleTableSlot slot 
)

Definition at line 1570 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 EvalPlanQualFetchRowMarks().

1571 {
1572  HeapTupleData tuple = {0};
1573  HeapTupleHeader td;
1574 
1575  td = DatumGetHeapTupleHeader(data);
1576 
1578  tuple.t_self = td->t_ctid;
1579  tuple.t_data = td;
1580 
1581  ExecClearTuple(slot);
1582 
1583  heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
1584  slot->tts_values, slot->tts_isnull);
1585  ExecStoreVirtualTuple(slot);
1586 }
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:426
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:1516
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ ExecStoreMinimalTuple()

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

Definition at line 1410 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().

1413 {
1414  /*
1415  * sanity checks
1416  */
1417  Assert(mtup != NULL);
1418  Assert(slot != NULL);
1419  Assert(slot->tts_tupleDescriptor != NULL);
1420 
1421  if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
1422  elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
1423  tts_minimal_store_tuple(slot, mtup, shouldFree);
1424 
1425  return slot;
1426 }
#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:597
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:732
#define elog(elevel,...)
Definition: elog.h:226
#define unlikely(x)
Definition: c.h:208

◆ ExecStorePinnedBufferHeapTuple()

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

Definition at line 1382 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().

1385 {
1386  /*
1387  * sanity checks
1388  */
1389  Assert(tuple != NULL);
1390  Assert(slot != NULL);
1391  Assert(slot->tts_tupleDescriptor != NULL);
1392  Assert(BufferIsValid(buffer));
1393 
1394  if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1395  elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1396  tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
1397 
1398  slot->tts_tableOid = tuple->t_tableOid;
1399 
1400  return slot;
1401 }
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:823
#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:732
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
#define elog(elevel,...)
Definition: elog.h:226
#define unlikely(x)
Definition: c.h:208

◆ ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot slot)

Definition at line 1516 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().

1517 {
1518  /*
1519  * sanity checks
1520  */
1521  Assert(slot != NULL);
1522  Assert(slot->tts_tupleDescriptor != NULL);
1523  Assert(TTS_EMPTY(slot));
1524 
1525  slot->tts_flags &= ~TTS_FLAG_EMPTY;
1526  slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
1527 
1528  return slot;
1529 }
#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:732
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ MakeSingleTupleTableSlot()

◆ MakeTupleTableSlot()

TupleTableSlot* MakeTupleTableSlot ( TupleDesc  tupleDesc,
const TupleTableSlotOps tts_ops 
)

Definition at line 1076 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().

1078 {
1079  Size basesz,
1080  allocsz;
1081  TupleTableSlot *slot;
1082 
1083  basesz = tts_ops->base_slot_size;
1084 
1085  /*
1086  * When a fixed descriptor is specified, we can reduce overhead by
1087  * allocating the entire slot in one go.
1088  */
1089  if (tupleDesc)
1090  allocsz = MAXALIGN(basesz) +
1091  MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
1092  MAXALIGN(tupleDesc->natts * sizeof(bool));
1093  else
1094  allocsz = basesz;
1095 
1096  slot = palloc0(allocsz);
1097  /* const for optimization purposes, OK to modify at allocation time */
1098  *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
1099  slot->type = T_TupleTableSlot;
1100  slot->tts_flags |= TTS_FLAG_EMPTY;
1101  if (tupleDesc != NULL)
1102  slot->tts_flags |= TTS_FLAG_FIXED;
1103  slot->tts_tupleDescriptor = tupleDesc;
1105  slot->tts_nvalid = 0;
1106 
1107  if (tupleDesc != NULL)
1108  {
1109  slot->tts_values = (Datum *)
1110  (((char *) slot)
1111  + MAXALIGN(basesz));
1112  slot->tts_isnull = (bool *)
1113  (((char *) slot)
1114  + MAXALIGN(basesz)
1115  + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
1116 
1117  PinTupleDesc(tupleDesc);
1118  }
1119 
1120  /*
1121  * And allow slot type specific initialization.
1122  */
1123  slot->tts_ops->init(slot);
1124 
1125  return slot;
1126 }
#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:955
uintptr_t Datum
Definition: postgres.h:367
#define TTS_FLAG_FIXED
Definition: tuptable.h:108
size_t Size
Definition: c.h:466
#define MAXALIGN(LEN)
Definition: c.h:685
#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 368 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().

369 {
370  AssertArg(attnum > 0);
371 
372  if (attnum > slot->tts_nvalid)
373  slot_getsomeattrs(slot, attnum);
374 
375  return slot->tts_isnull[attnum - 1];
376 }
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:342
bool * tts_isnull
Definition: tuptable.h:128
#define AssertArg(condition)
Definition: c.h:734
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

Definition at line 382 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(), ExecJustAssignInnerVar(), ExecJustAssignOuterVar(), ExecJustAssignScanVar(), ExecJustInnerVar(), ExecJustOuterVar(), ExecJustScanVar(), 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(), postquel_get_single_result(), ri_ExtractValues(), ri_KeysEqual(), ri_ReportViolation(), TupleHashTableHash(), update_frameheadpos(), update_frametailpos(), and validateDomainConstraint().

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

◆ slot_getmissingattrs()

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

Definition at line 1832 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().

1833 {
1834  AttrMissing *attrmiss = NULL;
1835 
1836  if (slot->tts_tupleDescriptor->constr)
1837  attrmiss = slot->tts_tupleDescriptor->constr->missing;
1838 
1839  if (!attrmiss)
1840  {
1841  /* no missing values array at all, so just fill everything in as NULL */
1842  memset(slot->tts_values + startAttNum, 0,
1843  (lastAttNum - startAttNum) * sizeof(Datum));
1844  memset(slot->tts_isnull + startAttNum, 1,
1845  (lastAttNum - startAttNum) * sizeof(bool));
1846  }
1847  else
1848  {
1849  int missattnum;
1850 
1851  /* if there is a missing values array we must process them one by one */
1852  for (missattnum = startAttNum;
1853  missattnum < lastAttNum;
1854  missattnum++)
1855  {
1856  slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
1857  slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
1858  }
1859 
1860  }
1861 }
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 342 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().

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

◆ slot_getsomeattrs_int()

void slot_getsomeattrs_int ( TupleTableSlot slot,
int  attnum 
)

Definition at line 1867 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().

1868 {
1869  /* Check for caller errors */
1870  Assert(slot->tts_nvalid < attnum); /* checked in slot_getsomeattrs */
1871  Assert(attnum > 0);
1872 
1873  if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
1874  elog(ERROR, "invalid attribute number %d", attnum);
1875 
1876  /* Fetch as many attributes as possible from the underlying tuple. */
1877  slot->tts_ops->getsomeattrs(slot, attnum);
1878 
1879  /*
1880  * If the underlying tuple doesn't have enough attributes, tuple
1881  * descriptor must have the missing attributes.
1882  */
1883  if (unlikely(slot->tts_nvalid < attnum))
1884  {
1885  slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
1886  slot->tts_nvalid = attnum;
1887  }
1888 }
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:732
void(* getsomeattrs)(TupleTableSlot *slot, int natts)
Definition: tuptable.h:161
void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
Definition: execTuples.c:1832
#define elog(elevel,...)
Definition: elog.h:226
#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 403 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().

404 {
405  AssertArg(attnum < 0); /* caller error */
406 
408  {
409  *isnull = false;
410  return ObjectIdGetDatum(slot->tts_tableOid);
411  }
413  {
414  *isnull = false;
415  return PointerGetDatum(&slot->tts_tid);
416  }
417 
418  /* Fetch the system attribute from the underlying tuple. */
419  return slot->tts_ops->getsysattr(slot, attnum, isnull);
420 }
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:734
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