PostgreSQL Source Code  git master
tuptable.h File Reference
#include "access/htup.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
#include "access/tupdesc.h"
#include "storage/buf.h"
Include dependency graph for tuptable.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  TupleTableSlot
 
struct  TupleTableSlotOps
 
struct  VirtualTupleTableSlot
 
struct  HeapTupleTableSlot
 
struct  BufferHeapTupleTableSlot
 
struct  MinimalTupleTableSlot
 

Macros

#define TTS_FLAG_EMPTY   (1 << 1)
 
#define TTS_EMPTY(slot)   (((slot)->tts_flags & TTS_FLAG_EMPTY) != 0)
 
#define TTS_FLAG_SHOULDFREE   (1 << 2)
 
#define TTS_SHOULDFREE(slot)   (((slot)->tts_flags & TTS_FLAG_SHOULDFREE) != 0)
 
#define TTS_FLAG_SLOW   (1 << 3)
 
#define TTS_SLOW(slot)   (((slot)->tts_flags & TTS_FLAG_SLOW) != 0)
 
#define TTS_FLAG_FIXED   (1 << 4)
 
#define TTS_FIXED(slot)   (((slot)->tts_flags & TTS_FLAG_FIXED) != 0)
 
#define FIELDNO_TUPLETABLESLOT_FLAGS   1
 
#define FIELDNO_TUPLETABLESLOT_NVALID   2
 
#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4
 
#define FIELDNO_TUPLETABLESLOT_VALUES   5
 
#define FIELDNO_TUPLETABLESLOT_ISNULL   6
 
#define TTS_IS_VIRTUAL(slot)   ((slot)->tts_ops == &TTSOpsVirtual)
 
#define TTS_IS_HEAPTUPLE(slot)   ((slot)->tts_ops == &TTSOpsHeapTuple)
 
#define TTS_IS_MINIMALTUPLE(slot)   ((slot)->tts_ops == &TTSOpsMinimalTuple)
 
#define TTS_IS_BUFFERTUPLE(slot)   ((slot)->tts_ops == &TTSOpsBufferHeapTuple)
 
#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1
 
#define FIELDNO_HEAPTUPLETABLESLOT_OFF   2
 
#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1
 
#define FIELDNO_MINIMALTUPLETABLESLOT_OFF   4
 
#define TupIsNull(slot)    ((slot) == NULL || TTS_EMPTY(slot))
 

Typedefs

typedef struct TupleTableSlotOps TupleTableSlotOps
 
typedef struct TupleTableSlot TupleTableSlot
 
typedef struct VirtualTupleTableSlot VirtualTupleTableSlot
 
typedef struct HeapTupleTableSlot HeapTupleTableSlot
 
typedef struct BufferHeapTupleTableSlot BufferHeapTupleTableSlot
 
typedef struct MinimalTupleTableSlot MinimalTupleTableSlot
 

Functions

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

◆ FIELDNO_HEAPTUPLETABLESLOT_TUPLE

#define FIELDNO_HEAPTUPLETABLESLOT_TUPLE   1

Definition at line 252 of file tuptable.h.

◆ FIELDNO_MINIMALTUPLETABLESLOT_OFF

#define FIELDNO_MINIMALTUPLETABLESLOT_OFF   4

Definition at line 292 of file tuptable.h.

◆ FIELDNO_MINIMALTUPLETABLESLOT_TUPLE

#define FIELDNO_MINIMALTUPLETABLESLOT_TUPLE   1

Definition at line 288 of file tuptable.h.

◆ FIELDNO_TUPLETABLESLOT_FLAGS

#define FIELDNO_TUPLETABLESLOT_FLAGS   1

Definition at line 117 of file tuptable.h.

◆ FIELDNO_TUPLETABLESLOT_ISNULL

#define FIELDNO_TUPLETABLESLOT_ISNULL   6

Definition at line 126 of file tuptable.h.

◆ FIELDNO_TUPLETABLESLOT_NVALID

#define FIELDNO_TUPLETABLESLOT_NVALID   2

Definition at line 119 of file tuptable.h.

◆ FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR

#define FIELDNO_TUPLETABLESLOT_TUPLEDESCRIPTOR   4

Definition at line 122 of file tuptable.h.

◆ FIELDNO_TUPLETABLESLOT_VALUES

#define FIELDNO_TUPLETABLESLOT_VALUES   5

Definition at line 124 of file tuptable.h.

◆ TTS_EMPTY

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

Definition at line 96 of file tuptable.h.

◆ TTS_FIXED

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

Definition at line 108 of file tuptable.h.

◆ TTS_FLAG_EMPTY

#define TTS_FLAG_EMPTY   (1 << 1)

Definition at line 95 of file tuptable.h.

◆ TTS_FLAG_FIXED

#define TTS_FLAG_FIXED   (1 << 4)

Definition at line 107 of file tuptable.h.

◆ TTS_FLAG_SHOULDFREE

#define TTS_FLAG_SHOULDFREE   (1 << 2)

Definition at line 99 of file tuptable.h.

◆ TTS_FLAG_SLOW

#define TTS_FLAG_SLOW   (1 << 3)

Definition at line 103 of file tuptable.h.

◆ TTS_IS_BUFFERTUPLE

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

Definition at line 230 of file tuptable.h.

◆ TTS_IS_HEAPTUPLE

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

Definition at line 228 of file tuptable.h.

◆ TTS_IS_MINIMALTUPLE

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

Definition at line 229 of file tuptable.h.

◆ TTS_IS_VIRTUAL

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

Definition at line 227 of file tuptable.h.

◆ TTS_SHOULDFREE

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

Definition at line 100 of file tuptable.h.

◆ TTS_SLOW

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

Definition at line 104 of file tuptable.h.

◆ TupIsNull

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

Definition at line 299 of file tuptable.h.

Typedef Documentation

◆ BufferHeapTupleTableSlot

◆ HeapTupleTableSlot

◆ MinimalTupleTableSlot

◆ TupleTableSlot

◆ TupleTableSlotOps

Definition at line 1 of file tuptable.h.

◆ VirtualTupleTableSlot

Function Documentation

◆ ExecAllocTableSlot()

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

Definition at line 1172 of file execTuples.c.

1174 {
1175  TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);
1176 
1177  *tupleTable = lappend(*tupleTable, slot);
1178 
1179  return slot;
1180 }
TupleTableSlot * MakeTupleTableSlot(TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1113
List * lappend(List *list, void *datum)
Definition: list.c:338

References lappend(), and MakeTupleTableSlot().

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

◆ ExecClearTuple()

static TupleTableSlot* ExecClearTuple ( TupleTableSlot slot)
inlinestatic

Definition at line 432 of file tuptable.h.

433 {
434  slot->tts_ops->clear(slot);
435 
436  return slot;
437 }
void(* clear)(TupleTableSlot *slot)
Definition: tuptable.h:151
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:121

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

Referenced by AfterTriggerExecute(), agg_retrieve_hash_table_in_memory(), apply_handle_update_internal(), apply_returning_filter(), ATRewriteTable(), begin_partition(), BitmapHeapNext(), buildSubPlanHash(), check_publications(), check_publications_origin(), CopyFrom(), CopyMultiInsertBufferFlush(), copyTemplateDependencies(), CteScanNext(), DefineTSConfiguration(), do_tup_output(), EnumValuesCreate(), eval_windowaggregates(), EvalPlanQual(), ExecAppend(), ExecAppendAsyncGetNext(), ExecARUpdateTriggers(), ExecBatchInsert(), ExecCheckTIDVisible(), ExecComputeStoredGenerated(), ExecDelete(), ExecDropSingleTupleTableSlot(), ExecEndAgg(), ExecEndBitmapHeapScan(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHashJoin(), ExecEndIncrementalSort(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndMaterial(), ExecEndMemoize(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNamedTuplestoreScan(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidRangeScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndValuesScan(), ExecEndWindowAgg(), ExecEndWorkTableScan(), ExecEvalAggOrderedTransTuple(), ExecEvalPreOrderedDistinctMulti(), ExecFilterJunk(), ExecFindPartition(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecHashJoinGetSavedTuple(), ExecHashSubPlan(), ExecIncrementalSort(), ExecLockRows(), ExecMaterial(), ExecMergeAppend(), ExecOnConflictUpdate(), ExecParallelHashJoinOuterGetTuple(), ExecProject(), ExecProjectSRF(), ExecReScanAgg(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanGroup(), ExecReScanIncrementalSort(), ExecReScanMaterial(), ExecReScanMergeJoin(), ExecReScanNamedTuplestoreScan(), ExecReScanSetOp(), ExecReScanSort(), ExecReScanTableFuncScan(), ExecReScanUnique(), ExecReScanValuesScan(), ExecReScanWindowAgg(), ExecReScanWorkTableScan(), ExecResetTupleTable(), ExecScan(), ExecScanFetch(), ExecScanReScan(), ExecSetSlotDescriptor(), ExecSort(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), ExecUnique(), execute_attr_map_slot(), ExecWindowAgg(), fetch_remote_table_info(), fetch_table_list(), fileIterateForeignScan(), finalize_aggregates(), FunctionNext(), gather_getnext(), gather_merge_clear_tuples(), gather_merge_init(), get_actual_variable_endpoint(), get_returning_data(), hashagg_spill_tuple(), heap_getnextslot(), heap_getnextslot_tidrange(), heapam_scan_analyze_next_tuple(), heapam_scan_sample_next_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), InsertPgAttributeTuples(), MakeConfigurationMapping(), ordered_set_shutdown(), ordered_set_transition_multi(), pgoutput_row_filter(), postgresIterateDirectModify(), postgresIterateForeignScan(), prepare_hash_slot(), prepare_probe_slot(), process_ordered_aggregate_multi(), recordMultipleDependencies(), RunFromStore(), setop_retrieve_direct(), setop_retrieve_hash_table(), ShutdownSetExpr(), slot_modify_data(), slot_store_data(), StoreIndexTuple(), switchToPresortedPrefixMode(), tablesample_getnext(), tfuncLoadRows(), TidNext(), TidRangeNext(), tts_buffer_heap_copyslot(), tuplesort_gettupleslot(), tuplestore_gettupleslot(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), ValuesNext(), and WinRowsArePeers().

◆ ExecCopySlot()

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

◆ ExecCopySlotHeapTuple()

static HeapTuple ExecCopySlotHeapTuple ( TupleTableSlot slot)
inlinestatic

◆ ExecCopySlotMinimalTuple()

static MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot slot)
inlinestatic

Definition at line 470 of file tuptable.h.

471 {
472  return slot->tts_ops->copy_minimal_tuple(slot);
473 }
MinimalTuple(* copy_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:215

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

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

◆ ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot ( TupleTableSlot slot)

Definition at line 1255 of file execTuples.c.

1256 {
1257  /* This should match ExecResetTupleTable's processing of one slot */
1258  Assert(IsA(slot, TupleTableSlot));
1259  ExecClearTuple(slot);
1260  slot->tts_ops->release(slot);
1261  if (slot->tts_tupleDescriptor)
1263  if (!TTS_FIXED(slot))
1264  {
1265  if (slot->tts_values)
1266  pfree(slot->tts_values);
1267  if (slot->tts_isnull)
1268  pfree(slot->tts_isnull);
1269  }
1270  pfree(slot);
1271 }
void pfree(void *pointer)
Definition: mcxt.c:1456
#define IsA(nodeptr, _type_)
Definition: nodes.h:179
void(* release)(TupleTableSlot *slot)
Definition: tuptable.h:143
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:123
bool * tts_isnull
Definition: tuptable.h:127
Datum * tts_values
Definition: tuptable.h:125
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:432
#define TTS_FIXED(slot)
Definition: tuptable.h:108

References Assert(), ExecClearTuple(), IsA, pfree(), TupleTableSlotOps::release, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by acquire_sample_rows(), AfterTriggerFreeQuery(), afterTriggerInvokeEvents(), AlterDomainNotNull(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), check_publications(), check_publications_origin(), compute_expr_stats(), compute_index_stats(), CopyMultiInsertBufferCleanup(), copyTemplateDependencies(), DefineTSConfiguration(), DoCopyTo(), end_tup_output(), EnumValuesCreate(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), freestate_cluster(), get_actual_variable_range(), get_rel_sync_entry(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), InsertPgAttributeTuples(), make_build_data(), MakeConfigurationMapping(), recordMultipleDependencies(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tstoreShutdownReceiver(), validateDomainConstraint(), and validateForeignKeyConstraint().

◆ ExecFetchSlotHeapTuple()

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

Definition at line 1645 of file execTuples.c.

1646 {
1647  /*
1648  * sanity checks
1649  */
1650  Assert(slot != NULL);
1651  Assert(!TTS_EMPTY(slot));
1652 
1653  /* Materialize the tuple so that the slot "owns" it, if requested. */
1654  if (materialize)
1655  slot->tts_ops->materialize(slot);
1656 
1657  if (slot->tts_ops->get_heap_tuple == NULL)
1658  {
1659  if (shouldFree)
1660  *shouldFree = true;
1661  return slot->tts_ops->copy_heap_tuple(slot);
1662  }
1663  else
1664  {
1665  if (shouldFree)
1666  *shouldFree = false;
1667  return slot->tts_ops->get_heap_tuple(slot);
1668  }
1669 }
HeapTuple(* get_heap_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:187
void(* materialize)(TupleTableSlot *slot)
Definition: tuptable.h:173

References Assert(), TupleTableSlotOps::copy_heap_tuple, TupleTableSlotOps::get_heap_tuple, TupleTableSlotOps::materialize, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by AfterTriggerExecute(), apply_returning_filter(), CatalogTuplesMultiInsertWithInfo(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecFetchSlotHeapTupleDatum(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), heap_multi_insert(), heapam_relation_copy_for_cluster(), heapam_tuple_complete_speculative(), heapam_tuple_insert(), heapam_tuple_insert_speculative(), heapam_tuple_update(), systable_getnext(), systable_getnext_ordered(), systable_recheck_tuple(), and validateForeignKeyConstraint().

◆ ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum ( TupleTableSlot slot)

Definition at line 1724 of file execTuples.c.

1725 {
1726  HeapTuple tup;
1727  TupleDesc tupdesc;
1728  bool shouldFree;
1729  Datum ret;
1730 
1731  /* Fetch slot's contents in regular-physical-tuple form */
1732  tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
1733  tupdesc = slot->tts_tupleDescriptor;
1734 
1735  /* Convert to Datum form */
1736  ret = heap_copy_tuple_as_datum(tup, tupdesc);
1737 
1738  if (shouldFree)
1739  pfree(tup);
1740 
1741  return ret;
1742 }
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition: execTuples.c:1645
Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
Definition: heaptuple.c:1072
uintptr_t Datum
Definition: postgres.h:64

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

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

◆ ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot slot,
bool shouldFree 
)

Definition at line 1693 of file execTuples.c.

1695 {
1696  /*
1697  * sanity checks
1698  */
1699  Assert(slot != NULL);
1700  Assert(!TTS_EMPTY(slot));
1701 
1702  if (slot->tts_ops->get_minimal_tuple)
1703  {
1704  if (shouldFree)
1705  *shouldFree = false;
1706  return slot->tts_ops->get_minimal_tuple(slot);
1707  }
1708  else
1709  {
1710  if (shouldFree)
1711  *shouldFree = true;
1712  return slot->tts_ops->copy_minimal_tuple(slot);
1713  }
1714 }
MinimalTuple(* get_minimal_tuple)(TupleTableSlot *slot)
Definition: tuptable.h:195

References Assert(), TupleTableSlotOps::copy_minimal_tuple, TupleTableSlotOps::get_minimal_tuple, TTS_EMPTY, and TupleTableSlot::tts_ops.

Referenced by ExecHashJoinImpl(), ExecHashSkewTableInsert(), ExecHashTableInsert(), ExecParallelHashJoinPartitionOuter(), ExecParallelHashTableInsert(), ExecParallelHashTableInsertCurrentBatch(), hashagg_spill_tuple(), and tqueueReceiveSlot().

◆ ExecForceStoreHeapTuple()

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

Definition at line 1470 of file execTuples.c.

1473 {
1474  if (TTS_IS_HEAPTUPLE(slot))
1475  {
1476  ExecStoreHeapTuple(tuple, slot, shouldFree);
1477  }
1478  else if (TTS_IS_BUFFERTUPLE(slot))
1479  {
1480  MemoryContext oldContext;
1482 
1483  ExecClearTuple(slot);
1484  slot->tts_flags &= ~TTS_FLAG_EMPTY;
1485  oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
1486  bslot->base.tuple = heap_copytuple(tuple);
1487  slot->tts_flags |= TTS_FLAG_SHOULDFREE;
1488  MemoryContextSwitchTo(oldContext);
1489 
1490  if (shouldFree)
1491  pfree(tuple);
1492  }
1493  else
1494  {
1495  ExecClearTuple(slot);
1497  slot->tts_values, slot->tts_isnull);
1498  ExecStoreVirtualTuple(slot);
1499 
1500  if (shouldFree)
1501  {
1502  ExecMaterializeSlot(slot);
1503  pfree(tuple);
1504  }
1505  }
1506 }
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1553
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition: execTuples.c:1353
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:768
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1337
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:138
MemoryContext tts_mcxt
Definition: tuptable.h:128
uint16 tts_flags
Definition: tuptable.h:118
#define TTS_FLAG_EMPTY
Definition: tuptable.h:95
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:99
#define TTS_IS_BUFFERTUPLE(slot)
Definition: tuptable.h:230
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:450
#define TTS_IS_HEAPTUPLE(slot)
Definition: tuptable.h:228

References ExecClearTuple(), ExecMaterializeSlot(), ExecStoreHeapTuple(), ExecStoreVirtualTuple(), heap_copytuple(), heap_deform_tuple(), MemoryContextSwitchTo(), pfree(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TTS_IS_BUFFERTUPLE, TTS_IS_HEAPTUPLE, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

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

◆ ExecForceStoreMinimalTuple()

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

Definition at line 1513 of file execTuples.c.

1516 {
1517  if (TTS_IS_MINIMALTUPLE(slot))
1518  {
1519  tts_minimal_store_tuple(slot, mtup, shouldFree);
1520  }
1521  else
1522  {
1523  HeapTupleData htup;
1524 
1525  ExecClearTuple(slot);
1526 
1527  htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
1528  htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
1530  slot->tts_values, slot->tts_isnull);
1531  ExecStoreVirtualTuple(slot);
1532 
1533  if (shouldFree)
1534  {
1535  ExecMaterializeSlot(slot);
1536  pfree(mtup);
1537  }
1538  }
1539 }
static void tts_minimal_store_tuple(TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
Definition: execTuples.c:621
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define MINIMAL_TUPLE_OFFSET
Definition: htup_details.h:617
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
#define TTS_IS_MINIMALTUPLE(slot)
Definition: tuptable.h:229

References ExecClearTuple(), ExecMaterializeSlot(), ExecStoreVirtualTuple(), heap_deform_tuple(), MINIMAL_TUPLE_OFFSET, pfree(), HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TTS_IS_MINIMALTUPLE, TupleTableSlot::tts_isnull, tts_minimal_store_tuple(), TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by ExecHashJoinGetSavedTuple(), ExecParallelHashJoinNewBatch(), and ExecParallelHashJoinOuterGetTuple().

◆ ExecMaterializeSlot()

◆ ExecResetTupleTable()

void ExecResetTupleTable ( List tupleTable,
bool  shouldFree 
)

Definition at line 1192 of file execTuples.c.

1194 {
1195  ListCell *lc;
1196 
1197  foreach(lc, tupleTable)
1198  {
1200 
1201  /* Always release resources and reset the slot to empty */
1202  ExecClearTuple(slot);
1203  slot->tts_ops->release(slot);
1204  if (slot->tts_tupleDescriptor)
1205  {
1207  slot->tts_tupleDescriptor = NULL;
1208  }
1209 
1210  /* If shouldFree, release memory occupied by the slot itself */
1211  if (shouldFree)
1212  {
1213  if (!TTS_FIXED(slot))
1214  {
1215  if (slot->tts_values)
1216  pfree(slot->tts_values);
1217  if (slot->tts_isnull)
1218  pfree(slot->tts_isnull);
1219  }
1220  pfree(slot);
1221  }
1222  }
1223 
1224  /* If shouldFree, release the list structure */
1225  if (shouldFree)
1226  list_free(tupleTable);
1227 }
void list_free(List *list)
Definition: list.c:1545
#define lfirst_node(type, lc)
Definition: pg_list.h:176

References ExecClearTuple(), lfirst_node, list_free(), pfree(), TupleTableSlotOps::release, ReleaseTupleDesc, TTS_FIXED, TupleTableSlot::tts_isnull, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by afterTriggerInvokeEvents(), CopyFrom(), EvalPlanQualEnd(), ExecEndPlan(), and finish_edata().

◆ ExecSetSlotDescriptor()

void ExecSetSlotDescriptor ( TupleTableSlot slot,
TupleDesc  tupdesc 
)

Definition at line 1290 of file execTuples.c.

1292 {
1293  Assert(!TTS_FIXED(slot));
1294 
1295  /* For safety, make sure slot is empty before changing it */
1296  ExecClearTuple(slot);
1297 
1298  /*
1299  * Release any old descriptor. Also release old Datum/isnull arrays if
1300  * present (we don't bother to check if they could be re-used).
1301  */
1302  if (slot->tts_tupleDescriptor)
1304 
1305  if (slot->tts_values)
1306  pfree(slot->tts_values);
1307  if (slot->tts_isnull)
1308  pfree(slot->tts_isnull);
1309 
1310  /*
1311  * Install the new descriptor; if it's refcounted, bump its refcount.
1312  */
1313  slot->tts_tupleDescriptor = tupdesc;
1314  PinTupleDesc(tupdesc);
1315 
1316  /*
1317  * Allocate Datum/isnull arrays of the appropriate size. These must have
1318  * the same lifetime as the slot, so allocate in the slot's own context.
1319  */
1320  slot->tts_values = (Datum *)
1321  MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
1322  slot->tts_isnull = (bool *)
1323  MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
1324 }
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1021
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116

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

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

◆ ExecStoreAllNullTuple()

TupleTableSlot* ExecStoreAllNullTuple ( TupleTableSlot slot)

Definition at line 1577 of file execTuples.c.

1578 {
1579  /*
1580  * sanity checks
1581  */
1582  Assert(slot != NULL);
1583  Assert(slot->tts_tupleDescriptor != NULL);
1584 
1585  /* Clear any old contents */
1586  ExecClearTuple(slot);
1587 
1588  /*
1589  * Fill all the columns of the virtual tuple with nulls
1590  */
1591  MemSet(slot->tts_values, 0,
1592  slot->tts_tupleDescriptor->natts * sizeof(Datum));
1593  memset(slot->tts_isnull, true,
1594  slot->tts_tupleDescriptor->natts * sizeof(bool));
1595 
1596  return ExecStoreVirtualTuple(slot);
1597 }
#define MemSet(start, val, len)
Definition: c.h:1009

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

◆ ExecStoreBufferHeapTuple()

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

Definition at line 1393 of file execTuples.c.

1396 {
1397  /*
1398  * sanity checks
1399  */
1400  Assert(tuple != NULL);
1401  Assert(slot != NULL);
1402  Assert(slot->tts_tupleDescriptor != NULL);
1403  Assert(BufferIsValid(buffer));
1404 
1405  if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1406  elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1407  tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
1408 
1409  slot->tts_tableOid = tuple->t_tableOid;
1410 
1411  return slot;
1412 }
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:301
#define unlikely(x)
Definition: c.h:300
#define ERROR
Definition: elog.h:39
static void tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
Definition: execTuples.c:860
Oid t_tableOid
Definition: htup.h:66
Oid tts_tableOid
Definition: tuptable.h:130

References Assert(), BufferIsValid(), elog(), ERROR, HeapTupleData::t_tableOid, tts_buffer_heap_store_tuple(), TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by heap_getnextslot(), heap_getnextslot_tidrange(), heapam_index_build_range_scan(), heapam_index_fetch_tuple(), heapam_scan_analyze_next_tuple(), heapam_scan_bitmap_next_tuple(), and heapam_scan_sample_next_tuple().

◆ ExecStoreHeapTuple()

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

Definition at line 1353 of file execTuples.c.

1356 {
1357  /*
1358  * sanity checks
1359  */
1360  Assert(tuple != NULL);
1361  Assert(slot != NULL);
1362  Assert(slot->tts_tupleDescriptor != NULL);
1363 
1364  if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
1365  elog(ERROR, "trying to store a heap tuple into wrong type of slot");
1366  tts_heap_store_tuple(slot, tuple, shouldFree);
1367 
1368  slot->tts_tableOid = tuple->t_tableOid;
1369 
1370  return slot;
1371 }
static void tts_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
Definition: execTuples.c:448

References Assert(), elog(), ERROR, HeapTupleData::t_tableOid, tts_heap_store_tuple(), TTS_IS_HEAPTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by CatalogIndexInsert(), comparetup_cluster_tiebreak(), compute_expr_stats(), compute_index_stats(), ExecForceStoreHeapTuple(), ExecuteCallStmt(), get_returning_data(), heapam_index_validate_scan(), make_build_data(), pgoutput_change(), postgresIterateForeignScan(), setop_retrieve_direct(), and tts_heap_copyslot().

◆ ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data,
TupleTableSlot slot 
)

Definition at line 1607 of file execTuples.c.

1608 {
1609  HeapTupleData tuple = {0};
1610  HeapTupleHeader td;
1611 
1613 
1615  tuple.t_self = td->t_ctid;
1616  tuple.t_data = td;
1617 
1618  ExecClearTuple(slot);
1619 
1620  heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
1621  slot->tts_values, slot->tts_isnull);
1622  ExecStoreVirtualTuple(slot);
1623 }
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:295
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:450
const void * data
ItemPointerData t_self
Definition: htup.h:65
ItemPointerData t_ctid
Definition: htup_details.h:161

References data, DatumGetHeapTupleHeader, ExecClearTuple(), ExecStoreVirtualTuple(), heap_deform_tuple(), HeapTupleHeaderGetDatumLength, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by EvalPlanQualFetchRowMark().

◆ ExecStoreMinimalTuple()

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

◆ ExecStorePinnedBufferHeapTuple()

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

Definition at line 1419 of file execTuples.c.

1422 {
1423  /*
1424  * sanity checks
1425  */
1426  Assert(tuple != NULL);
1427  Assert(slot != NULL);
1428  Assert(slot->tts_tupleDescriptor != NULL);
1429  Assert(BufferIsValid(buffer));
1430 
1431  if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
1432  elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
1433  tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
1434 
1435  slot->tts_tableOid = tuple->t_tableOid;
1436 
1437  return slot;
1438 }

References Assert(), BufferIsValid(), elog(), ERROR, HeapTupleData::t_tableOid, tts_buffer_heap_store_tuple(), TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by heapam_fetch_row_version(), and heapam_tuple_lock().

◆ ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot slot)

Definition at line 1553 of file execTuples.c.

1554 {
1555  /*
1556  * sanity checks
1557  */
1558  Assert(slot != NULL);
1559  Assert(slot->tts_tupleDescriptor != NULL);
1560  Assert(TTS_EMPTY(slot));
1561 
1562  slot->tts_flags &= ~TTS_FLAG_EMPTY;
1563  slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
1564 
1565  return slot;
1566 }
AttrNumber tts_nvalid
Definition: tuptable.h:120

References Assert(), TupleDescData::natts, TTS_EMPTY, TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_tupleDescriptor.

Referenced by agg_retrieve_hash_table_in_memory(), apply_returning_filter(), ATRewriteTable(), CopyFrom(), copyTemplateDependencies(), DefineTSConfiguration(), do_tup_output(), EnumValuesCreate(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecEvalPreOrderedDistinctMulti(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecSort(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hashagg_spill_tuple(), hypothetical_dense_rank_final(), hypothetical_rank_common(), InsertPgAttributeTuples(), MakeConfigurationMapping(), ordered_set_transition_multi(), pgoutput_row_filter(), prepare_hash_slot(), prepare_probe_slot(), recordMultipleDependencies(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_data(), slot_store_data(), StoreIndexTuple(), and ValuesNext().

◆ MakeSingleTupleTableSlot()

◆ MakeTupleTableSlot()

TupleTableSlot* MakeTupleTableSlot ( TupleDesc  tupleDesc,
const TupleTableSlotOps tts_ops 
)

Definition at line 1113 of file execTuples.c.

1115 {
1116  Size basesz,
1117  allocsz;
1118  TupleTableSlot *slot;
1119 
1120  basesz = tts_ops->base_slot_size;
1121 
1122  /*
1123  * When a fixed descriptor is specified, we can reduce overhead by
1124  * allocating the entire slot in one go.
1125  */
1126  if (tupleDesc)
1127  allocsz = MAXALIGN(basesz) +
1128  MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
1129  MAXALIGN(tupleDesc->natts * sizeof(bool));
1130  else
1131  allocsz = basesz;
1132 
1133  slot = palloc0(allocsz);
1134  /* const for optimization purposes, OK to modify at allocation time */
1135  *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
1136  slot->type = T_TupleTableSlot;
1137  slot->tts_flags |= TTS_FLAG_EMPTY;
1138  if (tupleDesc != NULL)
1139  slot->tts_flags |= TTS_FLAG_FIXED;
1140  slot->tts_tupleDescriptor = tupleDesc;
1142  slot->tts_nvalid = 0;
1143 
1144  if (tupleDesc != NULL)
1145  {
1146  slot->tts_values = (Datum *)
1147  (((char *) slot)
1148  + MAXALIGN(basesz));
1149  slot->tts_isnull = (bool *)
1150  (((char *) slot)
1151  + MAXALIGN(basesz)
1152  + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
1153 
1154  PinTupleDesc(tupleDesc);
1155  }
1156 
1157  /*
1158  * And allow slot type specific initialization.
1159  */
1160  slot->tts_ops->init(slot);
1161 
1162  return slot;
1163 }
#define MAXALIGN(LEN)
Definition: c.h:800
size_t Size
Definition: c.h:594
void * palloc0(Size size)
Definition: mcxt.c:1257
MemoryContext CurrentMemoryContext
Definition: mcxt.c:135
size_t base_slot_size
Definition: tuptable.h:137
void(* init)(TupleTableSlot *slot)
Definition: tuptable.h:140
NodeTag type
Definition: tuptable.h:116
#define TTS_FLAG_FIXED
Definition: tuptable.h:107

References TupleTableSlotOps::base_slot_size, CurrentMemoryContext, TupleTableSlotOps::init, MAXALIGN, TupleDescData::natts, palloc0(), PinTupleDesc, TTS_FLAG_EMPTY, TTS_FLAG_FIXED, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_ops, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and TupleTableSlot::type.

Referenced by ExecAllocTableSlot(), ExecConstraints(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), MakeSingleTupleTableSlot(), and pgoutput_change().

◆ slot_attisnull()

static bool slot_attisnull ( TupleTableSlot slot,
int  attnum 
)
inlinestatic

Definition at line 374 of file tuptable.h.

375 {
376  Assert(attnum > 0);
377 
378  if (attnum > slot->tts_nvalid)
379  slot_getsomeattrs(slot, attnum);
380 
381  return slot->tts_isnull[attnum - 1];
382 }
int16 attnum
Definition: pg_attribute.h:74
static void slot_getsomeattrs(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:348

References Assert(), attnum, slot_getsomeattrs(), TupleTableSlot::tts_isnull, and TupleTableSlot::tts_nvalid.

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

◆ slot_getallattrs()

◆ slot_getattr()

◆ slot_getmissingattrs()

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

Definition at line 1869 of file execTuples.c.

1870 {
1871  AttrMissing *attrmiss = NULL;
1872 
1873  if (slot->tts_tupleDescriptor->constr)
1874  attrmiss = slot->tts_tupleDescriptor->constr->missing;
1875 
1876  if (!attrmiss)
1877  {
1878  /* no missing values array at all, so just fill everything in as NULL */
1879  memset(slot->tts_values + startAttNum, 0,
1880  (lastAttNum - startAttNum) * sizeof(Datum));
1881  memset(slot->tts_isnull + startAttNum, 1,
1882  (lastAttNum - startAttNum) * sizeof(bool));
1883  }
1884  else
1885  {
1886  int missattnum;
1887 
1888  /* if there is a missing values array we must process them one by one */
1889  for (missattnum = startAttNum;
1890  missattnum < lastAttNum;
1891  missattnum++)
1892  {
1893  slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
1894  slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
1895  }
1896  }
1897 }
struct AttrMissing * missing
Definition: tupdesc.h:41
TupleConstr * constr
Definition: tupdesc.h:85

References AttrMissing::am_present, AttrMissing::am_value, TupleDescData::constr, TupleConstr::missing, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_getsomeattrs_int().

◆ slot_getsomeattrs()

static void slot_getsomeattrs ( TupleTableSlot slot,
int  attnum 
)
inlinestatic

◆ slot_getsomeattrs_int()

void slot_getsomeattrs_int ( TupleTableSlot slot,
int  attnum 
)

Definition at line 1903 of file execTuples.c.

1904 {
1905  /* Check for caller errors */
1906  Assert(slot->tts_nvalid < attnum); /* checked in slot_getsomeattrs */
1907  Assert(attnum > 0);
1908 
1909  if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
1910  elog(ERROR, "invalid attribute number %d", attnum);
1911 
1912  /* Fetch as many attributes as possible from the underlying tuple. */
1913  slot->tts_ops->getsomeattrs(slot, attnum);
1914 
1915  /*
1916  * If the underlying tuple doesn't have enough attributes, tuple
1917  * descriptor must have the missing attributes.
1918  */
1919  if (unlikely(slot->tts_nvalid < attnum))
1920  {
1921  slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
1922  slot->tts_nvalid = attnum;
1923  }
1924 }
void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
Definition: execTuples.c:1869
void(* getsomeattrs)(TupleTableSlot *slot, int natts)
Definition: tuptable.h:160

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

Referenced by slot_getsomeattrs().

◆ slot_getsysattr()

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

Definition at line 409 of file tuptable.h.

410 {
411  Assert(attnum < 0); /* caller error */
412 
414  {
415  *isnull = false;
416  return ObjectIdGetDatum(slot->tts_tableOid);
417  }
419  {
420  *isnull = false;
421  return PointerGetDatum(&slot->tts_tid);
422  }
423 
424  /* Fetch the system attribute from the underlying tuple. */
425  return slot->tts_ops->getsysattr(slot, attnum, isnull);
426 }
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
Datum(* getsysattr)(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:167
ItemPointerData tts_tid
Definition: tuptable.h:129
#define TableOidAttributeNumber
Definition: sysattr.h:26
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21

References Assert(), attnum, TupleTableSlotOps::getsysattr, ObjectIdGetDatum(), PointerGetDatum(), SelfItemPointerAttributeNumber, TableOidAttributeNumber, TupleTableSlot::tts_ops, TupleTableSlot::tts_tableOid, and TupleTableSlot::tts_tid.

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

Variable Documentation

◆ TTSOpsBufferHeapTuple

PGDLLIMPORT const TupleTableSlotOps TTSOpsBufferHeapTuple
extern

◆ TTSOpsHeapTuple

◆ TTSOpsMinimalTuple

◆ TTSOpsVirtual