PostgreSQL Source Code  git master
execTuples.c File Reference
#include "postgres.h"
#include "access/heaptoast.h"
#include "access/htup_details.h"
#include "access/tupdesc_details.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "nodes/nodeFuncs.h"
#include "storage/bufmgr.h"
#include "utils/builtins.h"
#include "utils/expandeddatum.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"
Include dependency graph for execTuples.c:

Go to the source code of this file.

Functions

static TupleDesc ExecTypeFromTLInternal (List *targetList, bool skipjunk)
 
static pg_attribute_always_inline void slot_deform_heap_tuple (TupleTableSlot *slot, HeapTuple tuple, uint32 *offp, int natts)
 
static void tts_buffer_heap_store_tuple (TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
 
static void tts_heap_store_tuple (TupleTableSlot *slot, HeapTuple tuple, bool shouldFree)
 
static void tts_virtual_init (TupleTableSlot *slot)
 
static void tts_virtual_release (TupleTableSlot *slot)
 
static void tts_virtual_clear (TupleTableSlot *slot)
 
static void tts_virtual_getsomeattrs (TupleTableSlot *slot, int natts)
 
static Datum tts_virtual_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
 
static void tts_virtual_materialize (TupleTableSlot *slot)
 
static void tts_virtual_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
 
static HeapTuple tts_virtual_copy_heap_tuple (TupleTableSlot *slot)
 
static MinimalTuple tts_virtual_copy_minimal_tuple (TupleTableSlot *slot)
 
static void tts_heap_init (TupleTableSlot *slot)
 
static void tts_heap_release (TupleTableSlot *slot)
 
static void tts_heap_clear (TupleTableSlot *slot)
 
static void tts_heap_getsomeattrs (TupleTableSlot *slot, int natts)
 
static Datum tts_heap_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
 
static void tts_heap_materialize (TupleTableSlot *slot)
 
static void tts_heap_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
 
static HeapTuple tts_heap_get_heap_tuple (TupleTableSlot *slot)
 
static HeapTuple tts_heap_copy_heap_tuple (TupleTableSlot *slot)
 
static MinimalTuple tts_heap_copy_minimal_tuple (TupleTableSlot *slot)
 
static void tts_minimal_init (TupleTableSlot *slot)
 
static void tts_minimal_release (TupleTableSlot *slot)
 
static void tts_minimal_clear (TupleTableSlot *slot)
 
static void tts_minimal_getsomeattrs (TupleTableSlot *slot, int natts)
 
static Datum tts_minimal_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
 
static void tts_minimal_materialize (TupleTableSlot *slot)
 
static void tts_minimal_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
 
static MinimalTuple tts_minimal_get_minimal_tuple (TupleTableSlot *slot)
 
static HeapTuple tts_minimal_copy_heap_tuple (TupleTableSlot *slot)
 
static MinimalTuple tts_minimal_copy_minimal_tuple (TupleTableSlot *slot)
 
static void tts_minimal_store_tuple (TupleTableSlot *slot, MinimalTuple mtup, bool shouldFree)
 
static void tts_buffer_heap_init (TupleTableSlot *slot)
 
static void tts_buffer_heap_release (TupleTableSlot *slot)
 
static void tts_buffer_heap_clear (TupleTableSlot *slot)
 
static void tts_buffer_heap_getsomeattrs (TupleTableSlot *slot, int natts)
 
static Datum tts_buffer_heap_getsysattr (TupleTableSlot *slot, int attnum, bool *isnull)
 
static void tts_buffer_heap_materialize (TupleTableSlot *slot)
 
static void tts_buffer_heap_copyslot (TupleTableSlot *dstslot, TupleTableSlot *srcslot)
 
static HeapTuple tts_buffer_heap_get_heap_tuple (TupleTableSlot *slot)
 
static HeapTuple tts_buffer_heap_copy_heap_tuple (TupleTableSlot *slot)
 
static MinimalTuple tts_buffer_heap_copy_minimal_tuple (TupleTableSlot *slot)
 
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)
 
TupleTableSlotExecStoreBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
 
TupleTableSlotExecStorePinnedBufferHeapTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
 
TupleTableSlotExecStoreMinimalTuple (MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
 
void ExecForceStoreHeapTuple (HeapTuple tuple, 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 ExecInitResultTypeTL (PlanState *planstate)
 
void ExecInitResultSlot (PlanState *planstate, const TupleTableSlotOps *tts_ops)
 
void ExecInitResultTupleSlotTL (PlanState *planstate, const TupleTableSlotOps *tts_ops)
 
void ExecInitScanTupleSlot (EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
 
TupleTableSlotExecInitExtraTupleSlot (EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
 
TupleTableSlotExecInitNullTupleSlot (EState *estate, TupleDesc tupType, const TupleTableSlotOps *tts_ops)
 
void slot_getmissingattrs (TupleTableSlot *slot, int startAttNum, int lastAttNum)
 
void slot_getsomeattrs_int (TupleTableSlot *slot, int attnum)
 
TupleDesc ExecTypeFromTL (List *targetList)
 
TupleDesc ExecCleanTypeFromTL (List *targetList)
 
TupleDesc ExecTypeFromExprList (List *exprList)
 
void ExecTypeSetColNames (TupleDesc typeInfo, List *namesList)
 
TupleDesc BlessTupleDesc (TupleDesc tupdesc)
 
AttInMetadataTupleDescGetAttInMetadata (TupleDesc tupdesc)
 
HeapTuple BuildTupleFromCStrings (AttInMetadata *attinmeta, char **values)
 
Datum HeapTupleHeaderGetDatum (HeapTupleHeader tuple)
 
TupOutputStatebegin_tup_output_tupdesc (DestReceiver *dest, TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
 
void do_tup_output (TupOutputState *tstate, Datum *values, bool *isnull)
 
void do_text_output_multiline (TupOutputState *tstate, const char *txt)
 
void end_tup_output (TupOutputState *tstate)
 

Variables

const TupleTableSlotOps TTSOpsVirtual
 
const TupleTableSlotOps TTSOpsHeapTuple
 
const TupleTableSlotOps TTSOpsMinimalTuple
 
const TupleTableSlotOps TTSOpsBufferHeapTuple
 

Function Documentation

◆ begin_tup_output_tupdesc()

TupOutputState* begin_tup_output_tupdesc ( DestReceiver dest,
TupleDesc  tupdesc,
const TupleTableSlotOps tts_ops 
)

Definition at line 2236 of file execTuples.c.

References CMD_SELECT, generate_unaccent_rules::dest, TupOutputState::dest, MakeSingleTupleTableSlot(), palloc(), _DestReceiver::rStartup, and TupOutputState::slot.

Referenced by CreateReplicationSlot(), ExecuteCallStmt(), ExplainQuery(), IdentifySystem(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

2239 {
2240  TupOutputState *tstate;
2241 
2242  tstate = (TupOutputState *) palloc(sizeof(TupOutputState));
2243 
2244  tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
2245  tstate->dest = dest;
2246 
2247  tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
2248 
2249  return tstate;
2250 }
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1208
TupleTableSlot * slot
Definition: executor.h:463
void(* rStartup)(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: dest.h:122
void * palloc(Size size)
Definition: mcxt.c:949
DestReceiver * dest
Definition: executor.h:464

◆ BlessTupleDesc()

TupleDesc BlessTupleDesc ( TupleDesc  tupdesc)

Definition at line 2052 of file execTuples.c.

References assign_record_type_typmod(), TupleDescData::tdtypeid, and TupleDescData::tdtypmod.

Referenced by aclexplode(), brin_metapage_info(), bt_page_items(), bt_page_items_bytea(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), exec_eval_datum(), ExecEvalWholeRowVar(), ExecInitExprRec(), ExecInitFunctionScan(), get_expr_result_type(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), init_sql_fcache(), pg_buffercache_pages(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_get_object_address(), pg_identify_object(), pg_identify_object_as_address(), pg_last_committed_xact(), pg_lock_status(), pg_partition_tree(), pg_prepared_xact(), pg_sequence_parameters(), pg_stat_file(), pg_stat_get_archiver(), pg_stats_ext_mcvlist_items(), pg_timezone_abbrevs(), pg_visibility_map_summary(), pg_visibility_tupdesc(), pg_walfile_name_offset(), pgstathashindex(), PLy_output_setup_record(), setup_firstcall(), ssl_extension_info(), test_predtest(), ts_setup_firstcall(), tsvector_unnest(), and TupleDescGetAttInMetadata().

2053 {
2054  if (tupdesc->tdtypeid == RECORDOID &&
2055  tupdesc->tdtypmod < 0)
2056  assign_record_type_typmod(tupdesc);
2057 
2058  return tupdesc; /* just for notational convenience */
2059 }
void assign_record_type_typmod(TupleDesc tupDesc)
Definition: typcache.c:1830
int32 tdtypmod
Definition: tupdesc.h:83
Oid tdtypeid
Definition: tupdesc.h:82

◆ BuildTupleFromCStrings()

HeapTuple BuildTupleFromCStrings ( AttInMetadata attinmeta,
char **  values 
)

Definition at line 2116 of file execTuples.c.

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, heap_form_tuple(), i, InputFunctionCall(), TupleDescData::natts, palloc(), pfree(), AttInMetadata::tupdesc, and TupleDescAttr.

Referenced by bt_metap(), bt_page_stats(), build_pgstattuple_type(), build_tuplestore_recursively(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), libpqrcv_processTuples(), materializeResult(), pg_config(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), prs_process_call(), show_all_settings(), storeRow(), ts_process_call(), tt_process_call(), and xpath_table().

2117 {
2118  TupleDesc tupdesc = attinmeta->tupdesc;
2119  int natts = tupdesc->natts;
2120  Datum *dvalues;
2121  bool *nulls;
2122  int i;
2123  HeapTuple tuple;
2124 
2125  dvalues = (Datum *) palloc(natts * sizeof(Datum));
2126  nulls = (bool *) palloc(natts * sizeof(bool));
2127 
2128  /*
2129  * Call the "in" function for each non-dropped attribute, even for nulls,
2130  * to support domains.
2131  */
2132  for (i = 0; i < natts; i++)
2133  {
2134  if (!TupleDescAttr(tupdesc, i)->attisdropped)
2135  {
2136  /* Non-dropped attributes */
2137  dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
2138  values[i],
2139  attinmeta->attioparams[i],
2140  attinmeta->atttypmods[i]);
2141  if (values[i] != NULL)
2142  nulls[i] = false;
2143  else
2144  nulls[i] = true;
2145  }
2146  else
2147  {
2148  /* Handle dropped attributes by setting to NULL */
2149  dvalues[i] = (Datum) 0;
2150  nulls[i] = true;
2151  }
2152  }
2153 
2154  /*
2155  * Form a tuple
2156  */
2157  tuple = heap_form_tuple(tupdesc, dvalues, nulls);
2158 
2159  /*
2160  * Release locally palloc'd space. XXX would probably be good to pfree
2161  * values of pass-by-reference datums, as well.
2162  */
2163  pfree(dvalues);
2164  pfree(nulls);
2165 
2166  return tuple;
2167 }
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
int32 * atttypmods
Definition: funcapi.h:47
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
Oid * attioparams
Definition: funcapi.h:44
void pfree(void *pointer)
Definition: mcxt.c:1056
TupleDesc tupdesc
Definition: funcapi.h:38
uintptr_t Datum
Definition: postgres.h:367
Datum InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1533
static Datum values[MAXATTR]
Definition: bootstrap.c:167
void * palloc(Size size)
Definition: mcxt.c:949
int i
FmgrInfo * attinfuncs
Definition: funcapi.h:41

◆ do_text_output_multiline()

void do_text_output_multiline ( TupOutputState tstate,
const char *  txt 
)

Definition at line 2284 of file execTuples.c.

References cstring_to_text_with_len(), DatumGetPointer, do_tup_output(), pfree(), PointerGetDatum, and values.

Referenced by ExplainQuery().

2285 {
2286  Datum values[1];
2287  bool isnull[1] = {false};
2288 
2289  while (*txt)
2290  {
2291  const char *eol;
2292  int len;
2293 
2294  eol = strchr(txt, '\n');
2295  if (eol)
2296  {
2297  len = eol - txt;
2298  eol++;
2299  }
2300  else
2301  {
2302  len = strlen(txt);
2303  eol = txt + len;
2304  }
2305 
2306  values[0] = PointerGetDatum(cstring_to_text_with_len(txt, len));
2307  do_tup_output(tstate, values, isnull);
2308  pfree(DatumGetPointer(values[0]));
2309  txt = eol;
2310  }
2311 }
#define PointerGetDatum(X)
Definition: postgres.h:556
void do_tup_output(TupOutputState *tstate, Datum *values, bool *isnull)
Definition: execTuples.c:2256
void pfree(void *pointer)
Definition: mcxt.c:1056
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:184
uintptr_t Datum
Definition: postgres.h:367
#define DatumGetPointer(X)
Definition: postgres.h:549
static Datum values[MAXATTR]
Definition: bootstrap.c:167

◆ do_tup_output()

void do_tup_output ( TupOutputState tstate,
Datum values,
bool isnull 
)

Definition at line 2256 of file execTuples.c.

References TupOutputState::dest, ExecClearTuple(), ExecStoreVirtualTuple(), TupleDescData::natts, _DestReceiver::receiveSlot, TupOutputState::slot, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by CreateReplicationSlot(), do_text_output_multiline(), IdentifySystem(), ShowAllGUCConfig(), and StartReplication().

2257 {
2258  TupleTableSlot *slot = tstate->slot;
2259  int natts = slot->tts_tupleDescriptor->natts;
2260 
2261  /* make sure the slot is clear */
2262  ExecClearTuple(slot);
2263 
2264  /* insert data */
2265  memcpy(slot->tts_values, values, natts * sizeof(Datum));
2266  memcpy(slot->tts_isnull, isnull, natts * sizeof(bool));
2267 
2268  /* mark slot as containing a virtual tuple */
2269  ExecStoreVirtualTuple(slot);
2270 
2271  /* send the tuple to the receiver */
2272  (void) tstate->dest->receiveSlot(slot, tstate->dest);
2273 
2274  /* clean up */
2275  ExecClearTuple(slot);
2276 }
bool(* receiveSlot)(TupleTableSlot *slot, DestReceiver *self)
Definition: dest.h:119
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot * slot
Definition: executor.h:463
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uintptr_t Datum
Definition: postgres.h:367
static Datum values[MAXATTR]
Definition: bootstrap.c:167
DestReceiver * dest
Definition: executor.h:464
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1522

◆ end_tup_output()

void end_tup_output ( TupOutputState tstate)

Definition at line 2314 of file execTuples.c.

References TupOutputState::dest, ExecDropSingleTupleTableSlot(), pfree(), _DestReceiver::rShutdown, and TupOutputState::slot.

Referenced by CreateReplicationSlot(), ExecuteCallStmt(), ExplainQuery(), IdentifySystem(), ShowAllGUCConfig(), ShowGUCConfigOption(), and StartReplication().

2315 {
2316  tstate->dest->rShutdown(tstate->dest);
2317  /* note that destroying the dest is not ours to do */
2319  pfree(tstate);
2320 }
TupleTableSlot * slot
Definition: executor.h:463
void pfree(void *pointer)
Definition: mcxt.c:1056
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1224
void(* rShutdown)(DestReceiver *self)
Definition: dest.h:125
DestReceiver * dest
Definition: executor.h:464

◆ ExecAllocTableSlot()

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

Definition at line 1141 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

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

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

◆ ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL ( List targetList)

Definition at line 1920 of file execTuples.c.

References ExecTypeFromTLInternal().

Referenced by ExecInitJunkFilter(), PlanCacheComputeResultDesc(), and PortalStart().

1921 {
1922  return ExecTypeFromTLInternal(targetList, true);
1923 }
static TupleDesc ExecTypeFromTLInternal(List *targetList, bool skipjunk)
Definition: execTuples.c:1926

◆ ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot ( TupleTableSlot slot)

Definition at line 1224 of file execTuples.c.

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

Referenced by acquire_sample_rows(), afterTriggerInvokeEvents(), AlterDomainNotNull(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), compute_index_stats(), CopyMultiInsertBufferCleanup(), CopyTo(), DefineQueryRewrite(), end_tup_output(), ExecCleanupTupleRouting(), ExecEndIncrementalSort(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tuplesort_free(), unique_key_recheck(), validateCheckConstraint(), validateDomainConstraint(), and validateForeignKeyConstraint().

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

◆ ExecFetchSlotHeapTuple()

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

Definition at line 1614 of file execTuples.c.

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

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

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

◆ ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum ( TupleTableSlot slot)

Definition at line 1693 of file execTuples.c.

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

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

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

◆ ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot slot,
bool shouldFree 
)

Definition at line 1662 of file execTuples.c.

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

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

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

◆ ExecForceStoreHeapTuple()

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

Definition at line 1439 of file execTuples.c.

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

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

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

◆ ExecForceStoreMinimalTuple()

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

Definition at line 1482 of file execTuples.c.

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

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

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

◆ ExecInitExtraTupleSlot()

◆ ExecInitNullTupleSlot()

TupleTableSlot* ExecInitNullTupleSlot ( EState estate,
TupleDesc  tupType,
const TupleTableSlotOps tts_ops 
)

Definition at line 1817 of file execTuples.c.

References ExecInitExtraTupleSlot(), and ExecStoreAllNullTuple().

Referenced by ExecInitHashJoin(), ExecInitMergeJoin(), and ExecInitNestLoop().

1819 {
1820  TupleTableSlot *slot = ExecInitExtraTupleSlot(estate, tupType, tts_ops);
1821 
1822  return ExecStoreAllNullTuple(slot);
1823 }
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1801
TupleTableSlot * ExecStoreAllNullTuple(TupleTableSlot *slot)
Definition: execTuples.c:1546

◆ ExecInitResultSlot()

void ExecInitResultSlot ( PlanState planstate,
const TupleTableSlotOps tts_ops 
)

Definition at line 1749 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), PlanState::ps_ResultTupleDesc, PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, and PlanState::state.

Referenced by ExecConditionalAssignProjectionInfo(), and ExecInitResultTupleSlotTL().

1750 {
1751  TupleTableSlot *slot;
1752 
1753  slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
1754  planstate->ps_ResultTupleDesc, tts_ops);
1755  planstate->ps_ResultTupleSlot = slot;
1756 
1757  planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
1758  planstate->resultops = tts_ops;
1759  planstate->resultopsset = true;
1760 }
EState * state
Definition: execnodes.h:947
const TupleTableSlotOps * resultops
Definition: execnodes.h:1020
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:983
bool resultopsset
Definition: execnodes.h:1028
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1141
TupleDesc ps_ResultTupleDesc
Definition: execnodes.h:982
List * es_tupleTable
Definition: execnodes.h:557
bool resultopsfixed
Definition: execnodes.h:1024

◆ ExecInitResultTupleSlotTL()

void ExecInitResultTupleSlotTL ( PlanState planstate,
const TupleTableSlotOps tts_ops 
)

◆ ExecInitResultTypeTL()

◆ ExecInitScanTupleSlot()

void ExecInitScanTupleSlot ( EState estate,
ScanState scanstate,
TupleDesc  tupledesc,
const TupleTableSlotOps tts_ops 
)

Definition at line 1781 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), ScanState::ps, PlanState::scandesc, PlanState::scanops, PlanState::scanopsfixed, PlanState::scanopsset, and ScanState::ss_ScanTupleSlot.

Referenced by ExecCreateScanSlotFromOuterPlan(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitNamedTuplestoreScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecInitWorkTableScan().

1783 {
1784  scanstate->ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable,
1785  tupledesc, tts_ops);
1786  scanstate->ps.scandesc = tupledesc;
1787  scanstate->ps.scanopsfixed = tupledesc != NULL;
1788  scanstate->ps.scanops = tts_ops;
1789  scanstate->ps.scanopsset = true;
1790 }
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1335
PlanState ps
Definition: execnodes.h:1332
const TupleTableSlotOps * scanops
Definition: execnodes.h:1017
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1141
List * es_tupleTable
Definition: execnodes.h:557
TupleDesc scandesc
Definition: execnodes.h:992
bool scanopsfixed
Definition: execnodes.h:1021
bool scanopsset
Definition: execnodes.h:1025

◆ ExecResetTupleTable()

void ExecResetTupleTable ( List tupleTable,
bool  shouldFree 
)

Definition at line 1161 of file execTuples.c.

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

Referenced by afterTriggerInvokeEvents(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), CopyFrom(), EvalPlanQualEnd(), and ExecEndPlan().

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

◆ ExecSetSlotDescriptor()

void ExecSetSlotDescriptor ( TupleTableSlot slot,
TupleDesc  tupdesc 
)

Definition at line 1259 of file execTuples.c.

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

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

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

◆ ExecStoreAllNullTuple()

TupleTableSlot* ExecStoreAllNullTuple ( TupleTableSlot slot)

Definition at line 1546 of file execTuples.c.

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

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

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

◆ ExecStoreBufferHeapTuple()

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

Definition at line 1362 of file execTuples.c.

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

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

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

◆ ExecStoreHeapTuple()

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

Definition at line 1322 of file execTuples.c.

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

Referenced by CatalogIndexInsert(), comparetup_cluster(), compute_index_stats(), ExecForceStoreHeapTuple(), ExecuteCallStmt(), gather_getnext(), gather_merge_readnext(), get_returning_data(), heapam_index_validate_scan(), postgresIterateForeignScan(), setop_retrieve_direct(), and tts_heap_copyslot().

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

◆ ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data,
TupleTableSlot slot 
)

Definition at line 1576 of file execTuples.c.

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

Referenced by EvalPlanQualFetchRowMark().

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

◆ ExecStoreMinimalTuple()

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

Definition at line 1416 of file execTuples.c.

References Assert, elog, ERROR, TTS_IS_MINIMALTUPLE, tts_minimal_store_tuple(), TupleTableSlot::tts_tupleDescriptor, and unlikely.

Referenced by agg_refill_hash_table(), agg_retrieve_hash_table_in_memory(), ExecParallelScanHashBucket(), ExecScanHashBucket(), ExecScanHashTableForUnmatched(), findPartialMatch(), setop_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash_internal(), TupleHashTableMatch(), tuplesort_gettupleslot(), and tuplestore_gettupleslot().

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

◆ ExecStorePinnedBufferHeapTuple()

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

Definition at line 1388 of file execTuples.c.

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

Referenced by heapam_fetch_row_version(), and heapam_tuple_lock().

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

◆ ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot slot)

Definition at line 1522 of file execTuples.c.

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

Referenced by agg_retrieve_hash_table_in_memory(), apply_returning_filter(), ATRewriteTable(), CopyFrom(), do_tup_output(), ExecComputeStoredGenerated(), ExecEvalAggOrderedTransTuple(), ExecFilterJunk(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecProjectSRF(), ExecStoreAllNullTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_slot(), fileIterateForeignScan(), FunctionNext(), hypothetical_dense_rank_final(), hypothetical_rank_common(), ordered_set_transition_multi(), prepare_hash_slot(), RI_Initial_Check(), RI_PartitionRemove_Check(), slot_modify_cstrings(), slot_store_cstrings(), StoreIndexTuple(), and ValuesNext().

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

◆ ExecTypeFromExprList()

TupleDesc ExecTypeFromExprList ( List exprList)

Definition at line 1967 of file execTuples.c.

References CreateTemplateTupleDesc(), exprCollation(), exprType(), exprTypmod(), lfirst, list_length(), TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecInitExprRec(), and ExecInitValuesScan().

1968 {
1969  TupleDesc typeInfo;
1970  ListCell *lc;
1971  int cur_resno = 1;
1972 
1973  typeInfo = CreateTemplateTupleDesc(list_length(exprList));
1974 
1975  foreach(lc, exprList)
1976  {
1977  Node *e = lfirst(lc);
1978 
1979  TupleDescInitEntry(typeInfo,
1980  cur_resno,
1981  NULL,
1982  exprType(e),
1983  exprTypmod(e),
1984  0);
1985  TupleDescInitEntryCollation(typeInfo,
1986  cur_resno,
1987  exprCollation(e));
1988  cur_resno++;
1989  }
1990 
1991  return typeInfo;
1992 }
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:44
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:275
Definition: nodes.h:529
void TupleDescInitEntryCollation(TupleDesc desc, AttrNumber attributeNumber, Oid collationid)
Definition: tupdesc.c:769
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:603
#define lfirst(lc)
Definition: pg_list.h:190
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
static int list_length(const List *l)
Definition: pg_list.h:169
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:719
e
Definition: preproc-init.c:82

◆ ExecTypeFromTL()

TupleDesc ExecTypeFromTL ( List targetList)

Definition at line 1908 of file execTuples.c.

References ExecTypeFromTLInternal().

Referenced by build_pertrans_for_aggref(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitIndexOnlyScan(), ExecInitModifyTable(), ExecInitPartitionInfo(), ExecInitResultTypeTL(), ExecInitSubPlan(), find_hash_columns(), and ordered_set_startup().

1909 {
1910  return ExecTypeFromTLInternal(targetList, false);
1911 }
static TupleDesc ExecTypeFromTLInternal(List *targetList, bool skipjunk)
Definition: execTuples.c:1926

◆ ExecTypeFromTLInternal()

static TupleDesc ExecTypeFromTLInternal ( List targetList,
bool  skipjunk 
)
static

Definition at line 1926 of file execTuples.c.

References CreateTemplateTupleDesc(), ExecCleanTargetListLength(), ExecTargetListLength(), TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), lfirst, TargetEntry::resjunk, TargetEntry::resname, TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecCleanTypeFromTL(), and ExecTypeFromTL().

1927 {
1928  TupleDesc typeInfo;
1929  ListCell *l;
1930  int len;
1931  int cur_resno = 1;
1932 
1933  if (skipjunk)
1934  len = ExecCleanTargetListLength(targetList);
1935  else
1936  len = ExecTargetListLength(targetList);
1937  typeInfo = CreateTemplateTupleDesc(len);
1938 
1939  foreach(l, targetList)
1940  {
1941  TargetEntry *tle = lfirst(l);
1942 
1943  if (skipjunk && tle->resjunk)
1944  continue;
1945  TupleDescInitEntry(typeInfo,
1946  cur_resno,
1947  tle->resname,
1948  exprType((Node *) tle->expr),
1949  exprTypmod((Node *) tle->expr),
1950  0);
1951  TupleDescInitEntryCollation(typeInfo,
1952  cur_resno,
1953  exprCollation((Node *) tle->expr));
1954  cur_resno++;
1955  }
1956 
1957  return typeInfo;
1958 }
int ExecTargetListLength(List *targetlist)
Definition: execUtils.c:1116
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:44
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:275
Definition: nodes.h:529
char * resname
Definition: primnodes.h:1409
bool resjunk
Definition: primnodes.h:1414
void TupleDescInitEntryCollation(TupleDesc desc, AttrNumber attributeNumber, Oid collationid)
Definition: tupdesc.c:769
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:603
int ExecCleanTargetListLength(List *targetlist)
Definition: execUtils.c:1126
#define lfirst(lc)
Definition: pg_list.h:190
Expr * expr
Definition: primnodes.h:1407
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:41
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:719

◆ ExecTypeSetColNames()

void ExecTypeSetColNames ( TupleDesc  typeInfo,
List namesList 
)

Definition at line 2006 of file execTuples.c.

References lfirst, NameStr, namestrcpy(), TupleDescData::natts, strVal, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr.

Referenced by ExecEvalWholeRowVar(), and ExecInitExprRec().

2007 {
2008  bool modified = false;
2009  int colno = 0;
2010  ListCell *lc;
2011 
2012  foreach(lc, namesList)
2013  {
2014  char *cname = strVal(lfirst(lc));
2015  Form_pg_attribute attr;
2016 
2017  /* Guard against too-long names list */
2018  if (colno >= typeInfo->natts)
2019  break;
2020  attr = TupleDescAttr(typeInfo, colno);
2021  colno++;
2022 
2023  /* Ignore empty aliases (these must be for dropped columns) */
2024  if (cname[0] == '\0')
2025  continue;
2026 
2027  /* Change tupdesc only if alias is actually different */
2028  if (strcmp(cname, NameStr(attr->attname)) != 0)
2029  {
2030  namestrcpy(&(attr->attname), cname);
2031  modified = true;
2032  }
2033  }
2034 
2035  /* If we modified the tupdesc, it's now a new record type */
2036  if (modified)
2037  {
2038  typeInfo->tdtypeid = RECORDOID;
2039  typeInfo->tdtypmod = -1;
2040  }
2041 }
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define strVal(v)
Definition: value.h:54
int namestrcpy(Name name, const char *str)
Definition: name.c:250
int32 tdtypmod
Definition: tupdesc.h:83
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
#define lfirst(lc)
Definition: pg_list.h:190
Oid tdtypeid
Definition: tupdesc.h:82
#define NameStr(name)
Definition: c.h:615

◆ HeapTupleHeaderGetDatum()

Datum HeapTupleHeaderGetDatum ( HeapTupleHeader  tuple)

Definition at line 2205 of file execTuples.c.

References HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, HeapTupleHeaderHasExternal, lookup_rowtype_tupdesc(), PointerGetDatum, ReleaseTupleDesc, and toast_flatten_tuple_to_datum().

Referenced by populate_composite(), and populate_recordset_record().

2206 {
2207  Datum result;
2208  TupleDesc tupDesc;
2209 
2210  /* No work if there are no external TOAST pointers in the tuple */
2211  if (!HeapTupleHeaderHasExternal(tuple))
2212  return PointerGetDatum(tuple);
2213 
2214  /* Use the type data saved by heap_form_tuple to look up the rowtype */
2216  HeapTupleHeaderGetTypMod(tuple));
2217 
2218  /* And do the flattening */
2219  result = toast_flatten_tuple_to_datum(tuple,
2221  tupDesc);
2222 
2223  ReleaseTupleDesc(tupDesc);
2224 
2225  return result;
2226 }
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition: typcache.c:1710
#define PointerGetDatum(X)
Definition: postgres.h:556
#define HeapTupleHeaderGetTypMod(tup)
Definition: htup_details.h:468
uintptr_t Datum
Definition: postgres.h:367
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:458
#define HeapTupleHeaderHasExternal(tup)
Definition: htup_details.h:539
Datum toast_flatten_tuple_to_datum(HeapTupleHeader tup, uint32 tup_len, TupleDesc tupleDesc)
Definition: heaptoast.c:449
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:452

◆ MakeSingleTupleTableSlot()

◆ MakeTupleTableSlot()

TupleTableSlot* MakeTupleTableSlot ( TupleDesc  tupleDesc,
const TupleTableSlotOps tts_ops 
)

Definition at line 1082 of file execTuples.c.

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

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

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

◆ slot_deform_heap_tuple()

static pg_attribute_always_inline void slot_deform_heap_tuple ( TupleTableSlot slot,
HeapTuple  tuple,
uint32 offp,
int  natts 
)
static

Definition at line 895 of file execTuples.c.

References att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull, attnum, TupleTableSlotOps::base_slot_size, fetchatt, HeapTupleHasNulls, HeapTupleHeaderGetNatts, init, Min, HeapTupleHeaderData::t_bits, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, tts_buffer_heap_clear(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_copy_minimal_tuple(), tts_buffer_heap_copyslot(), tts_buffer_heap_get_heap_tuple(), tts_buffer_heap_getsomeattrs(), tts_buffer_heap_getsysattr(), tts_buffer_heap_init(), tts_buffer_heap_materialize(), tts_buffer_heap_release(), TTS_FLAG_SLOW, tts_heap_clear(), tts_heap_copy_heap_tuple(), tts_heap_copy_minimal_tuple(), tts_heap_copyslot(), tts_heap_get_heap_tuple(), tts_heap_getsomeattrs(), tts_heap_getsysattr(), tts_heap_init(), tts_heap_materialize(), tts_heap_release(), TupleTableSlot::tts_isnull, tts_minimal_clear(), tts_minimal_copy_heap_tuple(), tts_minimal_copy_minimal_tuple(), tts_minimal_copyslot(), tts_minimal_get_minimal_tuple(), tts_minimal_getsomeattrs(), tts_minimal_getsysattr(), tts_minimal_init(), tts_minimal_materialize(), tts_minimal_release(), TupleTableSlot::tts_nvalid, TTS_SLOW, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, tts_virtual_clear(), tts_virtual_copy_heap_tuple(), tts_virtual_copy_minimal_tuple(), tts_virtual_copyslot(), tts_virtual_getsomeattrs(), tts_virtual_getsysattr(), tts_virtual_init(), tts_virtual_materialize(), tts_virtual_release(), TupleDescAttr, and values.

Referenced by tts_buffer_heap_getsomeattrs(), tts_heap_getsomeattrs(), and tts_minimal_getsomeattrs().

897 {
898  TupleDesc tupleDesc = slot->tts_tupleDescriptor;
899  Datum *values = slot->tts_values;
900  bool *isnull = slot->tts_isnull;
901  HeapTupleHeader tup = tuple->t_data;
902  bool hasnulls = HeapTupleHasNulls(tuple);
903  int attnum;
904  char *tp; /* ptr to tuple data */
905  uint32 off; /* offset in tuple data */
906  bits8 *bp = tup->t_bits; /* ptr to null bitmap in tuple */
907  bool slow; /* can we use/set attcacheoff? */
908 
909  /* We can only fetch as many attributes as the tuple has. */
910  natts = Min(HeapTupleHeaderGetNatts(tuple->t_data), natts);
911 
912  /*
913  * Check whether the first call for this tuple, and initialize or restore
914  * loop state.
915  */
916  attnum = slot->tts_nvalid;
917  if (attnum == 0)
918  {
919  /* Start from the first attribute */
920  off = 0;
921  slow = false;
922  }
923  else
924  {
925  /* Restore state from previous execution */
926  off = *offp;
927  slow = TTS_SLOW(slot);
928  }
929 
930  tp = (char *) tup + tup->t_hoff;
931 
932  for (; attnum < natts; attnum++)
933  {
934  Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
935 
936  if (hasnulls && att_isnull(attnum, bp))
937  {
938  values[attnum] = (Datum) 0;
939  isnull[attnum] = true;
940  slow = true; /* can't use attcacheoff anymore */
941  continue;
942  }
943 
944  isnull[attnum] = false;
945 
946  if (!slow && thisatt->attcacheoff >= 0)
947  off = thisatt->attcacheoff;
948  else if (thisatt->attlen == -1)
949  {
950  /*
951  * We can only cache the offset for a varlena attribute if the
952  * offset is already suitably aligned, so that there would be no
953  * pad bytes in any case: then the offset will be valid for either
954  * an aligned or unaligned value.
955  */
956  if (!slow &&
957  off == att_align_nominal(off, thisatt->attalign))
958  thisatt->attcacheoff = off;
959  else
960  {
961  off = att_align_pointer(off, thisatt->attalign, -1,
962  tp + off);
963  slow = true;
964  }
965  }
966  else
967  {
968  /* not varlena, so safe to use att_align_nominal */
969  off = att_align_nominal(off, thisatt->attalign);
970 
971  if (!slow)
972  thisatt->attcacheoff = off;
973  }
974 
975  values[attnum] = fetchatt(thisatt, tp + off);
976 
977  off = att_addlength_pointer(off, thisatt->attlen, tp + off);
978 
979  if (thisatt->attlen <= 0)
980  slow = true; /* can't use attcacheoff anymore */
981  }
982 
983  /*
984  * Save state for next execution
985  */
986  slot->tts_nvalid = attnum;
987  *offp = off;
988  if (slow)
989  slot->tts_flags |= TTS_FLAG_SLOW;
990  else
991  slot->tts_flags &= ~TTS_FLAG_SLOW;
992 }
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:148
bits8 t_bits[FLEXIBLE_ARRAY_MEMBER]
Definition: htup_details.h:177
#define att_isnull(ATT, BITS)
Definition: tupmacs.h:25
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define Min(x, y)
Definition: c.h:920
Datum * tts_values
Definition: tuptable.h:126
#define fetchatt(A, T)
Definition: tupmacs.h:41
HeapTupleHeader t_data
Definition: htup.h:68
uint16 tts_flags
Definition: tuptable.h:119
#define HeapTupleHeaderGetNatts(tup)
Definition: htup_details.h:531
#define HeapTupleHasNulls(tuple)
Definition: htup_details.h:661
bool * tts_isnull
Definition: tuptable.h:128
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
unsigned int uint32
Definition: c.h:367
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:176
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uint8 bits8
Definition: c.h:374
uintptr_t Datum
Definition: postgres.h:367
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition: tupmacs.h:126
int16 attnum
Definition: pg_attribute.h:79
static Datum values[MAXATTR]
Definition: bootstrap.c:167
#define TTS_SLOW(slot)
Definition: tuptable.h:105
AttrNumber tts_nvalid
Definition: tuptable.h:121
#define TTS_FLAG_SLOW
Definition: tuptable.h:104

◆ slot_getmissingattrs()

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

Definition at line 1838 of file execTuples.c.

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

Referenced by slot_getsomeattrs_int().

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

◆ slot_getsomeattrs_int()

void slot_getsomeattrs_int ( TupleTableSlot slot,
int  attnum 
)

Definition at line 1872 of file execTuples.c.

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

Referenced by slot_getsomeattrs().

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

◆ tts_buffer_heap_clear()

static void tts_buffer_heap_clear ( TupleTableSlot slot)
static

Definition at line 638 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, heap_freetuple(), InvalidBuffer, ItemPointerSetInvalid, HeapTupleTableSlot::off, ReleaseBuffer(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

639 {
641 
642  /*
643  * Free the memory for heap tuple if allowed. A tuple coming from buffer
644  * can never be freed. But we may have materialized a tuple from buffer.
645  * Such a tuple can be freed.
646  */
647  if (TTS_SHOULDFREE(slot))
648  {
649  /* We should have unpinned the buffer while materializing the tuple. */
650  Assert(!BufferIsValid(bslot->buffer));
651 
652  heap_freetuple(bslot->base.tuple);
653  slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
654  }
655 
656  if (BufferIsValid(bslot->buffer))
657  ReleaseBuffer(bslot->buffer);
658 
659  slot->tts_nvalid = 0;
660  slot->tts_flags |= TTS_FLAG_EMPTY;
662  bslot->base.tuple = NULL;
663  bslot->base.off = 0;
664  bslot->buffer = InvalidBuffer;
665 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
#define InvalidBuffer
Definition: buf.h:25
HeapTuple tuple
Definition: tuptable.h:250
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3483
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1338
uint16 tts_flags
Definition: tuptable.h:119
#define Assert(condition)
Definition: c.h:738
#define BufferIsValid(bufnum)
Definition: bufmgr.h:123
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
AttrNumber tts_nvalid
Definition: tuptable.h:121
HeapTupleTableSlot base
Definition: tuptable.h:259
ItemPointerData tts_tid
Definition: tuptable.h:130

◆ tts_buffer_heap_copy_heap_tuple()

static HeapTuple tts_buffer_heap_copy_heap_tuple ( TupleTableSlot slot)
static

Definition at line 803 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, heap_copytuple(), tts_buffer_heap_materialize(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

804 {
806 
807  Assert(!TTS_EMPTY(slot));
808 
809  if (!bslot->base.tuple)
811 
812  return heap_copytuple(bslot->base.tuple);
813 }
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
#define Assert(condition)
Definition: c.h:738
static void tts_buffer_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:689
HeapTupleTableSlot base
Definition: tuptable.h:259

◆ tts_buffer_heap_copy_minimal_tuple()

static MinimalTuple tts_buffer_heap_copy_minimal_tuple ( TupleTableSlot slot)
static

Definition at line 816 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, minimal_tuple_from_heap_tuple(), tts_buffer_heap_materialize(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

817 {
819 
820  Assert(!TTS_EMPTY(slot));
821 
822  if (!bslot->base.tuple)
824 
826 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
#define Assert(condition)
Definition: c.h:738
static void tts_buffer_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:689
MinimalTuple minimal_tuple_from_heap_tuple(HeapTuple htup)
Definition: heaptuple.c:1480
HeapTupleTableSlot base
Definition: tuptable.h:259

◆ tts_buffer_heap_copyslot()

static void tts_buffer_heap_copyslot ( TupleTableSlot dstslot,
TupleTableSlot srcslot 
)
static

Definition at line 748 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, ExecClearTuple(), ExecCopySlotHeapTuple(), MemoryContextSwitchTo(), tts_buffer_heap_store_tuple(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_ops, TTS_SHOULDFREE, HeapTupleTableSlot::tupdata, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

749 {
750  BufferHeapTupleTableSlot *bsrcslot = (BufferHeapTupleTableSlot *) srcslot;
751  BufferHeapTupleTableSlot *bdstslot = (BufferHeapTupleTableSlot *) dstslot;
752 
753  /*
754  * If the source slot is of a different kind, or is a buffer slot that has
755  * been materialized / is virtual, make a new copy of the tuple. Otherwise
756  * make a new reference to the in-buffer tuple.
757  */
758  if (dstslot->tts_ops != srcslot->tts_ops ||
759  TTS_SHOULDFREE(srcslot) ||
760  !bsrcslot->base.tuple)
761  {
762  MemoryContext oldContext;
763 
764  ExecClearTuple(dstslot);
765  dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
766  oldContext = MemoryContextSwitchTo(dstslot->tts_mcxt);
767  bdstslot->base.tuple = ExecCopySlotHeapTuple(srcslot);
768  dstslot->tts_flags |= TTS_FLAG_SHOULDFREE;
769  MemoryContextSwitchTo(oldContext);
770  }
771  else
772  {
773  Assert(BufferIsValid(bsrcslot->buffer));
774 
775  tts_buffer_heap_store_tuple(dstslot, bsrcslot->base.tuple,
776  bsrcslot->buffer, false);
777 
778  /*
779  * The HeapTupleData portion of the source tuple might be shorter
780  * lived than the destination slot. Therefore copy the HeapTuple into
781  * our slot's tupdata, which is guaranteed to live long enough (but
782  * will still point into the buffer).
783  */
784  memcpy(&bdstslot->base.tupdata, bdstslot->base.tuple, sizeof(HeapTupleData));
785  bdstslot->base.tuple = &bdstslot->base.tupdata;
786  }
787 }
static void tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple, Buffer buffer, bool transfer_pin)
Definition: execTuples.c:829
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
HeapTuple tuple
Definition: tuptable.h:250
MemoryContext tts_mcxt
Definition: tuptable.h:129
uint16 tts_flags
Definition: tuptable.h:119
static HeapTuple ExecCopySlotHeapTuple(TupleTableSlot *slot)
Definition: tuptable.h:452
#define Assert(condition)
Definition: c.h:738
#define BufferIsValid(bufnum)
Definition: bufmgr.h:123
HeapTupleTableSlot base
Definition: tuptable.h:259
HeapTupleData tupdata
Definition: tuptable.h:253

◆ tts_buffer_heap_get_heap_tuple()

static HeapTuple tts_buffer_heap_get_heap_tuple ( TupleTableSlot slot)
static

Definition at line 790 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, tts_buffer_heap_materialize(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

791 {
793 
794  Assert(!TTS_EMPTY(slot));
795 
796  if (!bslot->base.tuple)
798 
799  return bslot->base.tuple;
800 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
#define Assert(condition)
Definition: c.h:738
static void tts_buffer_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:689
HeapTupleTableSlot base
Definition: tuptable.h:259

◆ tts_buffer_heap_getsomeattrs()

static void tts_buffer_heap_getsomeattrs ( TupleTableSlot slot,
int  natts 
)
static

Definition at line 668 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, HeapTupleTableSlot::off, slot_deform_heap_tuple(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

669 {
671 
672  Assert(!TTS_EMPTY(slot));
673 
674  slot_deform_heap_tuple(slot, bslot->base.tuple, &bslot->base.off, natts);
675 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
static pg_attribute_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp, int natts)
Definition: execTuples.c:895
#define Assert(condition)
Definition: c.h:738
HeapTupleTableSlot base
Definition: tuptable.h:259

◆ tts_buffer_heap_getsysattr()

static Datum tts_buffer_heap_getsysattr ( TupleTableSlot slot,
int  attnum,
bool isnull 
)
static

Definition at line 678 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, heap_getsysattr(), TTS_EMPTY, TupleTableSlot::tts_tupleDescriptor, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

679 {
681 
682  Assert(!TTS_EMPTY(slot));
683 
684  return heap_getsysattr(bslot->base.tuple, attnum,
685  slot->tts_tupleDescriptor, isnull);
686 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
Datum heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: heaptuple.c:627
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
int16 attnum
Definition: pg_attribute.h:79
#define Assert(condition)
Definition: c.h:738
HeapTupleTableSlot base
Definition: tuptable.h:259

◆ tts_buffer_heap_init()

static void tts_buffer_heap_init ( TupleTableSlot slot)
static

Definition at line 628 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

629 {
630 }

◆ tts_buffer_heap_materialize()

static void tts_buffer_heap_materialize ( TupleTableSlot slot)
static

Definition at line 689 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, heap_copytuple(), heap_form_tuple(), InvalidBuffer, likely, MemoryContextSwitchTo(), HeapTupleTableSlot::off, ReleaseBuffer(), TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_copy_minimal_tuple(), and tts_buffer_heap_get_heap_tuple().

690 {
692  MemoryContext oldContext;
693 
694  Assert(!TTS_EMPTY(slot));
695 
696  /* If slot has its tuple already materialized, nothing to do. */
697  if (TTS_SHOULDFREE(slot))
698  return;
699 
700  oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
701 
702  /*
703  * Have to deform from scratch, otherwise tts_values[] entries could point
704  * into the non-materialized tuple (which might be gone when accessed).
705  */
706  bslot->base.off = 0;
707  slot->tts_nvalid = 0;
708 
709  if (!bslot->base.tuple)
710  {
711  /*
712  * Normally BufferHeapTupleTableSlot should have a tuple + buffer
713  * associated with it, unless it's materialized (which would've
714  * returned above). But when it's useful to allow storing virtual
715  * tuples in a buffer slot, which then also needs to be
716  * materializable.
717  */
719  slot->tts_values,
720  slot->tts_isnull);
721  }
722  else
723  {
724  bslot->base.tuple = heap_copytuple(bslot->base.tuple);
725 
726  /*
727  * A heap tuple stored in a BufferHeapTupleTableSlot should have a
728  * buffer associated with it, unless it's materialized or virtual.
729  */
730  if (likely(BufferIsValid(bslot->buffer)))
731  ReleaseBuffer(bslot->buffer);
732  bslot->buffer = InvalidBuffer;
733  }
734 
735  /*
736  * We don't set TTS_FLAG_SHOULDFREE until after releasing the buffer, if
737  * any. This avoids having a transient state that would fall foul of our
738  * assertions that a slot with TTS_FLAG_SHOULDFREE doesn't own a buffer.
739  * In the unlikely event that ReleaseBuffer() above errors out, we'd
740  * effectively leak the copied tuple, but that seems fairly harmless.
741  */
743 
744  MemoryContextSwitchTo(oldContext);
745 }
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
#define likely(x)
Definition: c.h:205
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
#define InvalidBuffer
Definition: buf.h:25
HeapTuple tuple
Definition: tuptable.h:250
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3483
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
uint16 tts_flags
Definition: tuptable.h:119
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:738
#define BufferIsValid(bufnum)
Definition: bufmgr.h:123
AttrNumber tts_nvalid
Definition: tuptable.h:121
HeapTupleTableSlot base
Definition: tuptable.h:259

◆ tts_buffer_heap_release()

static void tts_buffer_heap_release ( TupleTableSlot slot)
static

Definition at line 633 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

634 {
635 }

◆ tts_buffer_heap_store_tuple()

static void tts_buffer_heap_store_tuple ( TupleTableSlot slot,
HeapTuple  tuple,
Buffer  buffer,
bool  transfer_pin 
)
inlinestatic

Definition at line 829 of file execTuples.c.

References Assert, BufferHeapTupleTableSlot::base, BufferHeapTupleTableSlot::buffer, BufferIsValid, heap_freetuple(), IncrBufferRefCount(), HeapTupleTableSlot::off, pg_attribute_always_inline, ReleaseBuffer(), HeapTupleData::t_self, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by ExecStoreBufferHeapTuple(), ExecStorePinnedBufferHeapTuple(), and tts_buffer_heap_copyslot().

831 {
833 
834  if (TTS_SHOULDFREE(slot))
835  {
836  /* materialized slot shouldn't have a buffer to release */
837  Assert(!BufferIsValid(bslot->buffer));
838 
839  heap_freetuple(bslot->base.tuple);
840  slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
841  }
842 
843  slot->tts_flags &= ~TTS_FLAG_EMPTY;
844  slot->tts_nvalid = 0;
845  bslot->base.tuple = tuple;
846  bslot->base.off = 0;
847  slot->tts_tid = tuple->t_self;
848 
849  /*
850  * If tuple is on a disk page, keep the page pinned as long as we hold a
851  * pointer into it. We assume the caller already has such a pin. If
852  * transfer_pin is true, we'll transfer that pin to this slot, if not
853  * we'll pin it again ourselves.
854  *
855  * This is coded to optimize the case where the slot previously held a
856  * tuple on the same disk page: in that case releasing and re-acquiring
857  * the pin is a waste of cycles. This is a common situation during
858  * seqscans, so it's worth troubling over.
859  */
860  if (bslot->buffer != buffer)
861  {
862  if (BufferIsValid(bslot->buffer))
863  ReleaseBuffer(bslot->buffer);
864 
865  bslot->buffer = buffer;
866 
867  if (!transfer_pin && BufferIsValid(buffer))
868  IncrBufferRefCount(buffer);
869  }
870  else if (transfer_pin && BufferIsValid(buffer))
871  {
872  /*
873  * In transfer_pin mode the caller won't know about the same-page
874  * optimization, so we gotta release its pin.
875  */
876  ReleaseBuffer(buffer);
877  }
878 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
HeapTuple tuple
Definition: tuptable.h:250
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3483
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1338
uint16 tts_flags
Definition: tuptable.h:119
ItemPointerData t_self
Definition: htup.h:65
#define Assert(condition)
Definition: c.h:738
#define BufferIsValid(bufnum)
Definition: bufmgr.h:123
AttrNumber tts_nvalid
Definition: tuptable.h:121
HeapTupleTableSlot base
Definition: tuptable.h:259
ItemPointerData tts_tid
Definition: tuptable.h:130
void IncrBufferRefCount(Buffer buffer)
Definition: bufmgr.c:3521

◆ tts_heap_clear()

static void tts_heap_clear ( TupleTableSlot slot)
static

Definition at line 303 of file execTuples.c.

References heap_freetuple(), ItemPointerSetInvalid, HeapTupleTableSlot::off, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), and tts_heap_store_tuple().

304 {
305  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
306 
307  /* Free the memory for the heap tuple if it's allowed. */
308  if (TTS_SHOULDFREE(slot))
309  {
310  heap_freetuple(hslot->tuple);
311  slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
312  }
313 
314  slot->tts_nvalid = 0;
315  slot->tts_flags |= TTS_FLAG_EMPTY;
317  hslot->off = 0;
318  hslot->tuple = NULL;
319 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
HeapTuple tuple
Definition: tuptable.h:250
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1338
uint16 tts_flags
Definition: tuptable.h:119
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
AttrNumber tts_nvalid
Definition: tuptable.h:121
ItemPointerData tts_tid
Definition: tuptable.h:130

◆ tts_heap_copy_heap_tuple()

static HeapTuple tts_heap_copy_heap_tuple ( TupleTableSlot slot)
static

Definition at line 408 of file execTuples.c.

References Assert, heap_copytuple(), TTS_EMPTY, tts_heap_materialize(), and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

409 {
410  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
411 
412  Assert(!TTS_EMPTY(slot));
413  if (!hslot->tuple)
414  tts_heap_materialize(slot);
415 
416  return heap_copytuple(hslot->tuple);
417 }
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
static void tts_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:343
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
#define Assert(condition)
Definition: c.h:738

◆ tts_heap_copy_minimal_tuple()

static MinimalTuple tts_heap_copy_minimal_tuple ( TupleTableSlot slot)
static

Definition at line 420 of file execTuples.c.

References minimal_tuple_from_heap_tuple(), tts_heap_materialize(), and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

421 {
422  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
423 
424  if (!hslot->tuple)
425  tts_heap_materialize(slot);
426 
427  return minimal_tuple_from_heap_tuple(hslot->tuple);
428 }
static void tts_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:343
HeapTuple tuple
Definition: tuptable.h:250
MinimalTuple minimal_tuple_from_heap_tuple(HeapTuple htup)
Definition: heaptuple.c:1480

◆ tts_heap_copyslot()

static void tts_heap_copyslot ( TupleTableSlot dstslot,
TupleTableSlot srcslot 
)
static

Definition at line 383 of file execTuples.c.

References ExecCopySlotHeapTuple(), ExecStoreHeapTuple(), MemoryContextSwitchTo(), and TupleTableSlot::tts_mcxt.

Referenced by slot_deform_heap_tuple().

384 {
385  HeapTuple tuple;
386  MemoryContext oldcontext;
387 
388  oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
389  tuple = ExecCopySlotHeapTuple(srcslot);
390  MemoryContextSwitchTo(oldcontext);
391 
392  ExecStoreHeapTuple(tuple, dstslot, true);
393 }
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
MemoryContext tts_mcxt
Definition: tuptable.h:129
static HeapTuple ExecCopySlotHeapTuple(TupleTableSlot *slot)
Definition: tuptable.h:452
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition: execTuples.c:1322

◆ tts_heap_get_heap_tuple()

static HeapTuple tts_heap_get_heap_tuple ( TupleTableSlot slot)
static

Definition at line 396 of file execTuples.c.

References Assert, TTS_EMPTY, tts_heap_materialize(), and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

397 {
398  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
399 
400  Assert(!TTS_EMPTY(slot));
401  if (!hslot->tuple)
402  tts_heap_materialize(slot);
403 
404  return hslot->tuple;
405 }
static void tts_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:343
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
#define Assert(condition)
Definition: c.h:738

◆ tts_heap_getsomeattrs()

static void tts_heap_getsomeattrs ( TupleTableSlot slot,
int  natts 
)
static

Definition at line 322 of file execTuples.c.

References Assert, HeapTupleTableSlot::off, slot_deform_heap_tuple(), TTS_EMPTY, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

323 {
324  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
325 
326  Assert(!TTS_EMPTY(slot));
327 
328  slot_deform_heap_tuple(slot, hslot->tuple, &hslot->off, natts);
329 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
static pg_attribute_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp, int natts)
Definition: execTuples.c:895
#define Assert(condition)
Definition: c.h:738

◆ tts_heap_getsysattr()

static Datum tts_heap_getsysattr ( TupleTableSlot slot,
int  attnum,
bool isnull 
)
static

Definition at line 332 of file execTuples.c.

References Assert, heap_getsysattr(), TTS_EMPTY, TupleTableSlot::tts_tupleDescriptor, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

333 {
334  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
335 
336  Assert(!TTS_EMPTY(slot));
337 
338  return heap_getsysattr(hslot->tuple, attnum,
339  slot->tts_tupleDescriptor, isnull);
340 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTuple tuple
Definition: tuptable.h:250
Datum heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: heaptuple.c:627
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
int16 attnum
Definition: pg_attribute.h:79
#define Assert(condition)
Definition: c.h:738

◆ tts_heap_init()

static void tts_heap_init ( TupleTableSlot slot)
static

Definition at line 293 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

294 {
295 }

◆ tts_heap_materialize()

static void tts_heap_materialize ( TupleTableSlot slot)
static

Definition at line 343 of file execTuples.c.

References Assert, heap_copytuple(), heap_form_tuple(), MemoryContextSwitchTo(), HeapTupleTableSlot::off, TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and HeapTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), tts_heap_copy_heap_tuple(), tts_heap_copy_minimal_tuple(), and tts_heap_get_heap_tuple().

344 {
345  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
346  MemoryContext oldContext;
347 
348  Assert(!TTS_EMPTY(slot));
349 
350  /* If slot has its tuple already materialized, nothing to do. */
351  if (TTS_SHOULDFREE(slot))
352  return;
353 
354  oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
355 
356  /*
357  * Have to deform from scratch, otherwise tts_values[] entries could point
358  * into the non-materialized tuple (which might be gone when accessed).
359  */
360  slot->tts_nvalid = 0;
361  hslot->off = 0;
362 
363  if (!hslot->tuple)
365  slot->tts_values,
366  slot->tts_isnull);
367  else
368  {
369  /*
370  * The tuple contained in this slot is not allocated in the memory
371  * context of the given slot (else it would have TTS_SHOULDFREE set).
372  * Copy the tuple into the given slot's memory context.
373  */
374  hslot->tuple = heap_copytuple(hslot->tuple);
375  }
376 
378 
379  MemoryContextSwitchTo(oldContext);
380 }
HeapTuple heap_copytuple(HeapTuple tuple)
Definition: heaptuple.c:680
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
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
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
uint16 tts_flags
Definition: tuptable.h:119
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:738
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ tts_heap_release()

static void tts_heap_release ( TupleTableSlot slot)
static

Definition at line 298 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

299 {
300 }

◆ tts_heap_store_tuple()

static void tts_heap_store_tuple ( TupleTableSlot slot,
HeapTuple  tuple,
bool  shouldFree 
)
static

Definition at line 431 of file execTuples.c.

References HeapTupleTableSlot::off, HeapTupleData::t_self, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, tts_heap_clear(), TupleTableSlot::tts_nvalid, TupleTableSlot::tts_tid, and HeapTupleTableSlot::tuple.

Referenced by ExecStoreHeapTuple().

432 {
433  HeapTupleTableSlot *hslot = (HeapTupleTableSlot *) slot;
434 
435  tts_heap_clear(slot);
436 
437  slot->tts_nvalid = 0;
438  hslot->tuple = tuple;
439  hslot->off = 0;
441  slot->tts_tid = tuple->t_self;
442 
443  if (shouldFree)
445 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
HeapTuple tuple
Definition: tuptable.h:250
static void tts_heap_clear(TupleTableSlot *slot)
Definition: execTuples.c:303
uint16 tts_flags
Definition: tuptable.h:119
ItemPointerData t_self
Definition: htup.h:65
AttrNumber tts_nvalid
Definition: tuptable.h:121
ItemPointerData tts_tid
Definition: tuptable.h:130

◆ tts_minimal_clear()

static void tts_minimal_clear ( TupleTableSlot slot)
static

Definition at line 470 of file execTuples.c.

References heap_free_minimal_tuple(), ItemPointerSetInvalid, MinimalTupleTableSlot::mintuple, MinimalTupleTableSlot::off, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and TupleTableSlot::tts_tid.

Referenced by slot_deform_heap_tuple(), and tts_minimal_store_tuple().

471 {
473 
474  if (TTS_SHOULDFREE(slot))
475  {
477  slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
478  }
479 
480  slot->tts_nvalid = 0;
481  slot->tts_flags |= TTS_FLAG_EMPTY;
483  mslot->off = 0;
484  mslot->mintuple = NULL;
485 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
uint16 tts_flags
Definition: tuptable.h:119
void heap_free_minimal_tuple(MinimalTuple mtup)
Definition: heaptuple.c:1427
MinimalTuple mintuple
Definition: tuptable.h:283
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
AttrNumber tts_nvalid
Definition: tuptable.h:121
ItemPointerData tts_tid
Definition: tuptable.h:130

◆ tts_minimal_copy_heap_tuple()

static HeapTuple tts_minimal_copy_heap_tuple ( TupleTableSlot slot)
static

Definition at line 577 of file execTuples.c.

References heap_tuple_from_minimal_tuple(), MinimalTupleTableSlot::mintuple, and tts_minimal_materialize().

Referenced by slot_deform_heap_tuple().

578 {
580 
581  if (!mslot->mintuple)
583 
585 }
static void tts_minimal_materialize(TupleTableSlot *slot)
Definition: execTuples.c:506
HeapTuple heap_tuple_from_minimal_tuple(MinimalTuple mtup)
Definition: heaptuple.c:1458
MinimalTuple mintuple
Definition: tuptable.h:283

◆ tts_minimal_copy_minimal_tuple()

static MinimalTuple tts_minimal_copy_minimal_tuple ( TupleTableSlot slot)
static

Definition at line 588 of file execTuples.c.

References heap_copy_minimal_tuple(), MinimalTupleTableSlot::mintuple, and tts_minimal_materialize().

Referenced by slot_deform_heap_tuple().

589 {
591 
592  if (!mslot->mintuple)
594 
595  return heap_copy_minimal_tuple(mslot->mintuple);
596 }
static void tts_minimal_materialize(TupleTableSlot *slot)
Definition: execTuples.c:506
MinimalTuple heap_copy_minimal_tuple(MinimalTuple mtup)
Definition: heaptuple.c:1439
MinimalTuple mintuple
Definition: tuptable.h:283

◆ tts_minimal_copyslot()

static void tts_minimal_copyslot ( TupleTableSlot dstslot,
TupleTableSlot srcslot 
)
static

Definition at line 553 of file execTuples.c.

References ExecCopySlotMinimalTuple(), ExecStoreMinimalTuple(), MemoryContextSwitchTo(), and TupleTableSlot::tts_mcxt.

Referenced by slot_deform_heap_tuple().

554 {
555  MemoryContext oldcontext;
556  MinimalTuple mintuple;
557 
558  oldcontext = MemoryContextSwitchTo(dstslot->tts_mcxt);
559  mintuple = ExecCopySlotMinimalTuple(srcslot);
560  MemoryContextSwitchTo(oldcontext);
561 
562  ExecStoreMinimalTuple(mintuple, dstslot, true);
563 }
TupleTableSlot * ExecStoreMinimalTuple(MinimalTuple mtup, TupleTableSlot *slot, bool shouldFree)
Definition: execTuples.c:1416
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
MemoryContext tts_mcxt
Definition: tuptable.h:129
static MinimalTuple ExecCopySlotMinimalTuple(TupleTableSlot *slot)
Definition: tuptable.h:463

◆ tts_minimal_get_minimal_tuple()

static MinimalTuple tts_minimal_get_minimal_tuple ( TupleTableSlot slot)
static

Definition at line 566 of file execTuples.c.

References MinimalTupleTableSlot::mintuple, and tts_minimal_materialize().

Referenced by slot_deform_heap_tuple().

567 {
569 
570  if (!mslot->mintuple)
572 
573  return mslot->mintuple;
574 }
static void tts_minimal_materialize(TupleTableSlot *slot)
Definition: execTuples.c:506
MinimalTuple mintuple
Definition: tuptable.h:283

◆ tts_minimal_getsomeattrs()

static void tts_minimal_getsomeattrs ( TupleTableSlot slot,
int  natts 
)
static

Definition at line 488 of file execTuples.c.

References Assert, MinimalTupleTableSlot::off, slot_deform_heap_tuple(), TTS_EMPTY, and MinimalTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

489 {
491 
492  Assert(!TTS_EMPTY(slot));
493 
494  slot_deform_heap_tuple(slot, mslot->tuple, &mslot->off, natts);
495 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
static pg_attribute_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp, int natts)
Definition: execTuples.c:895
#define Assert(condition)
Definition: c.h:738

◆ tts_minimal_getsysattr()

static Datum tts_minimal_getsysattr ( TupleTableSlot slot,
int  attnum,
bool isnull 
)
static

Definition at line 498 of file execTuples.c.

References elog, and ERROR.

Referenced by slot_deform_heap_tuple().

499 {
500  elog(ERROR, "minimal tuple table slot does not have system attributes");
501 
502  return 0; /* silence compiler warnings */
503 }
#define ERROR
Definition: elog.h:43
#define elog(elevel,...)
Definition: elog.h:214

◆ tts_minimal_init()

static void tts_minimal_init ( TupleTableSlot slot)
static

Definition at line 453 of file execTuples.c.

References MinimalTupleTableSlot::minhdr, and MinimalTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple().

454 {
456 
457  /*
458  * Initialize the heap tuple pointer to access attributes of the minimal
459  * tuple contained in the slot as if its a heap tuple.
460  */
461  mslot->tuple = &mslot->minhdr;
462 }
HeapTupleData minhdr
Definition: tuptable.h:284

◆ tts_minimal_materialize()

static void tts_minimal_materialize ( TupleTableSlot slot)
static

Definition at line 506 of file execTuples.c.

References Assert, heap_copy_minimal_tuple(), heap_form_minimal_tuple(), MemoryContextSwitchTo(), MinimalTupleTableSlot::minhdr, MINIMAL_TUPLE_OFFSET, MinimalTupleTableSlot::mintuple, MinimalTupleTableSlot::off, HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TTS_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, and MinimalTupleTableSlot::tuple.

Referenced by slot_deform_heap_tuple(), tts_minimal_copy_heap_tuple(), tts_minimal_copy_minimal_tuple(), and tts_minimal_get_minimal_tuple().

507 {
509  MemoryContext oldContext;
510 
511  Assert(!TTS_EMPTY(slot));
512 
513  /* If slot has its tuple already materialized, nothing to do. */
514  if (TTS_SHOULDFREE(slot))
515  return;
516 
517  oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
518 
519  /*
520  * Have to deform from scratch, otherwise tts_values[] entries could point
521  * into the non-materialized tuple (which might be gone when accessed).
522  */
523  slot->tts_nvalid = 0;
524  mslot->off = 0;
525 
526  if (!mslot->mintuple)
527  {
529  slot->tts_values,
530  slot->tts_isnull);
531  }
532  else
533  {
534  /*
535  * The minimal tuple contained in this slot is not allocated in the
536  * memory context of the given slot (else it would have TTS_SHOULDFREE
537  * set). Copy the minimal tuple into the given slot's memory context.
538  */
539  mslot->mintuple = heap_copy_minimal_tuple(mslot->mintuple);
540  }
541 
543 
544  Assert(mslot->tuple == &mslot->minhdr);
545 
546  mslot->minhdr.t_len = mslot->mintuple->t_len + MINIMAL_TUPLE_OFFSET;
547  mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mslot->mintuple - MINIMAL_TUPLE_OFFSET);
548 
549  MemoryContextSwitchTo(oldContext);
550 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
MinimalTuple heap_copy_minimal_tuple(MinimalTuple mtup)
Definition: heaptuple.c:1439
HeapTupleHeader t_data
Definition: htup.h:68
uint16 tts_flags
Definition: tuptable.h:119
uint32 t_len
Definition: htup.h:64
bool * tts_isnull
Definition: tuptable.h:128
MinimalTuple heap_form_minimal_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1356
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:738
#define MINIMAL_TUPLE_OFFSET
Definition: htup_details.h:619
MinimalTuple mintuple
Definition: tuptable.h:283
HeapTupleData minhdr
Definition: tuptable.h:284
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ tts_minimal_release()

static void tts_minimal_release ( TupleTableSlot slot)
static

Definition at line 465 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

466 {
467 }

◆ tts_minimal_store_tuple()

static void tts_minimal_store_tuple ( TupleTableSlot slot,
MinimalTuple  mtup,
bool  shouldFree 
)
static

Definition at line 599 of file execTuples.c.

References Assert, MinimalTupleTableSlot::minhdr, MINIMAL_TUPLE_OFFSET, MinimalTupleTableSlot::mintuple, MinimalTupleTableSlot::off, HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TTS_EMPTY, TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, tts_minimal_clear(), TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, and MinimalTupleTableSlot::tuple.

Referenced by ExecForceStoreMinimalTuple(), and ExecStoreMinimalTuple().

600 {
602 
603  tts_minimal_clear(slot);
604 
605  Assert(!TTS_SHOULDFREE(slot));
606  Assert(TTS_EMPTY(slot));
607 
608  slot->tts_flags &= ~TTS_FLAG_EMPTY;
609  slot->tts_nvalid = 0;
610  mslot->off = 0;
611 
612  mslot->mintuple = mtup;
613  Assert(mslot->tuple == &mslot->minhdr);
614  mslot->minhdr.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
615  mslot->minhdr.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
616  /* no need to set t_self or t_tableOid since we won't allow access */
617 
618  if (shouldFree)
620 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
HeapTupleHeader t_data
Definition: htup.h:68
uint16 tts_flags
Definition: tuptable.h:119
uint32 t_len
Definition: htup.h:64
static void tts_minimal_clear(TupleTableSlot *slot)
Definition: execTuples.c:470
#define Assert(condition)
Definition: c.h:738
#define MINIMAL_TUPLE_OFFSET
Definition: htup_details.h:619
MinimalTuple mintuple
Definition: tuptable.h:283
HeapTupleData minhdr
Definition: tuptable.h:284
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ tts_virtual_clear()

static void tts_virtual_clear ( TupleTableSlot slot)
static

Definition at line 107 of file execTuples.c.

References VirtualTupleTableSlot::data, ItemPointerSetInvalid, pfree(), TTS_FLAG_EMPTY, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, TTS_SHOULDFREE, TupleTableSlot::tts_tid, and unlikely.

Referenced by slot_deform_heap_tuple(), and tts_virtual_copyslot().

108 {
109  if (unlikely(TTS_SHOULDFREE(slot)))
110  {
112 
113  pfree(vslot->data);
114  vslot->data = NULL;
115 
116  slot->tts_flags &= ~TTS_FLAG_SHOULDFREE;
117  }
118 
119  slot->tts_nvalid = 0;
120  slot->tts_flags |= TTS_FLAG_EMPTY;
122 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
uint16 tts_flags
Definition: tuptable.h:119
void pfree(void *pointer)
Definition: mcxt.c:1056
#define ItemPointerSetInvalid(pointer)
Definition: itemptr.h:172
#define unlikely(x)
Definition: c.h:206
AttrNumber tts_nvalid
Definition: tuptable.h:121
ItemPointerData tts_tid
Definition: tuptable.h:130

◆ tts_virtual_copy_heap_tuple()

static HeapTuple tts_virtual_copy_heap_tuple ( TupleTableSlot slot)
static

Definition at line 268 of file execTuples.c.

References Assert, heap_form_tuple(), TTS_EMPTY, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_deform_heap_tuple().

269 {
270  Assert(!TTS_EMPTY(slot));
271 
273  slot->tts_values,
274  slot->tts_isnull);
275 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
Datum * tts_values
Definition: tuptable.h:126
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:738

◆ tts_virtual_copy_minimal_tuple()

static MinimalTuple tts_virtual_copy_minimal_tuple ( TupleTableSlot slot)
static

Definition at line 278 of file execTuples.c.

References Assert, heap_form_minimal_tuple(), TTS_EMPTY, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by slot_deform_heap_tuple().

279 {
280  Assert(!TTS_EMPTY(slot));
281 
283  slot->tts_values,
284  slot->tts_isnull);
285 }
#define TTS_EMPTY(slot)
Definition: tuptable.h:97
Datum * tts_values
Definition: tuptable.h:126
bool * tts_isnull
Definition: tuptable.h:128
MinimalTuple heap_form_minimal_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1356
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
#define Assert(condition)
Definition: c.h:738

◆ tts_virtual_copyslot()

static void tts_virtual_copyslot ( TupleTableSlot dstslot,
TupleTableSlot srcslot 
)
static

Definition at line 244 of file execTuples.c.

References Assert, TupleDescData::natts, slot_getallattrs(), TTS_FLAG_EMPTY, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, tts_virtual_clear(), and tts_virtual_materialize().

Referenced by slot_deform_heap_tuple().

245 {
246  TupleDesc srcdesc = srcslot->tts_tupleDescriptor;
247 
248  Assert(srcdesc->natts <= dstslot->tts_tupleDescriptor->natts);
249 
250  tts_virtual_clear(dstslot);
251 
252  slot_getallattrs(srcslot);
253 
254  for (int natt = 0; natt < srcdesc->natts; natt++)
255  {
256  dstslot->tts_values[natt] = srcslot->tts_values[natt];
257  dstslot->tts_isnull[natt] = srcslot->tts_isnull[natt];
258  }
259 
260  dstslot->tts_nvalid = srcdesc->natts;
261  dstslot->tts_flags &= ~TTS_FLAG_EMPTY;
262 
263  /* make sure storage doesn't depend on external memory */
264  tts_virtual_materialize(dstslot);
265 }
#define TTS_FLAG_EMPTY
Definition: tuptable.h:96
Datum * tts_values
Definition: tuptable.h:126
uint16 tts_flags
Definition: tuptable.h:119
static void slot_getallattrs(TupleTableSlot *slot)
Definition: tuptable.h:354
bool * tts_isnull
Definition: tuptable.h:128
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
static void tts_virtual_materialize(TupleTableSlot *slot)
Definition: execTuples.c:151
#define Assert(condition)
Definition: c.h:738
static void tts_virtual_clear(TupleTableSlot *slot)
Definition: execTuples.c:107
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ tts_virtual_getsomeattrs()

static void tts_virtual_getsomeattrs ( TupleTableSlot slot,
int  natts 
)
static

Definition at line 130 of file execTuples.c.

References elog, and ERROR.

Referenced by slot_deform_heap_tuple().

131 {
132  elog(ERROR, "getsomeattrs is not required to be called on a virtual tuple table slot");
133 }
#define ERROR
Definition: elog.h:43
#define elog(elevel,...)
Definition: elog.h:214

◆ tts_virtual_getsysattr()

static Datum tts_virtual_getsysattr ( TupleTableSlot slot,
int  attnum,
bool isnull 
)
static

Definition at line 136 of file execTuples.c.

References elog, and ERROR.

Referenced by slot_deform_heap_tuple().

137 {
138  elog(ERROR, "virtual tuple table slot does not have system attributes");
139 
140  return 0; /* silence compiler warnings */
141 }
#define ERROR
Definition: elog.h:43
#define elog(elevel,...)
Definition: elog.h:214

◆ tts_virtual_init()

static void tts_virtual_init ( TupleTableSlot slot)
static

Definition at line 97 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

98 {
99 }

◆ tts_virtual_materialize()

static void tts_virtual_materialize ( TupleTableSlot slot)
static

Definition at line 151 of file execTuples.c.

References att_addlength_datum, att_align_nominal, VirtualTupleTableSlot::data, DatumGetEOHP(), DatumGetPointer, EOH_flatten_into(), EOH_get_flat_size(), MemoryContextAlloc(), TupleDescData::natts, PointerGetDatum, TTS_FLAG_SHOULDFREE, TupleTableSlot::tts_flags, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TTS_SHOULDFREE, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescAttr, val, and VARATT_IS_EXTERNAL_EXPANDED.

Referenced by slot_deform_heap_tuple(), and tts_virtual_copyslot().

152 {
154  TupleDesc desc = slot->tts_tupleDescriptor;
155  Size sz = 0;
156  char *data;
157 
158  /* already materialized */
159  if (TTS_SHOULDFREE(slot))
160  return;
161 
162  /* compute size of memory required */
163  for (int natt = 0; natt < desc->natts; natt++)
164  {
165  Form_pg_attribute att = TupleDescAttr(desc, natt);
166  Datum val;
167 
168  if (att->attbyval || slot->tts_isnull[natt])
169  continue;
170 
171  val = slot->tts_values[natt];
172 
173  if (att->attlen == -1 &&
175  {
176  /*
177  * We want to flatten the expanded value so that the materialized
178  * slot doesn't depend on it.
179  */
180  sz = att_align_nominal(sz, att->attalign);
181  sz += EOH_get_flat_size(DatumGetEOHP(val));
182  }
183  else
184  {
185  sz = att_align_nominal(sz, att->attalign);
186  sz = att_addlength_datum(sz, att->attlen, val);
187  }
188  }
189 
190  /* all data is byval */
191  if (sz == 0)
192  return;
193 
194  /* allocate memory */
195  vslot->data = data = MemoryContextAlloc(slot->tts_mcxt, sz);
197 
198  /* and copy all attributes into the pre-allocated space */
199  for (int natt = 0; natt < desc->natts; natt++)
200  {
201  Form_pg_attribute att = TupleDescAttr(desc, natt);
202  Datum val;
203 
204  if (att->attbyval || slot->tts_isnull[natt])
205  continue;
206 
207  val = slot->tts_values[natt];
208 
209  if (att->attlen == -1 &&
211  {
212  Size data_length;
213 
214  /*
215  * We want to flatten the expanded value so that the materialized
216  * slot doesn't depend on it.
217  */
219 
220  data = (char *) att_align_nominal(data,
221  att->attalign);
222  data_length = EOH_get_flat_size(eoh);
223  EOH_flatten_into(eoh, data, data_length);
224 
225  slot->tts_values[natt] = PointerGetDatum(data);
226  data += data_length;
227  }
228  else
229  {
230  Size data_length = 0;
231 
232  data = (char *) att_align_nominal(data, att->attalign);
233  data_length = att_addlength_datum(data_length, att->attlen, val);
234 
235  memcpy(data, DatumGetPointer(val), data_length);
236 
237  slot->tts_values[natt] = PointerGetDatum(data);
238  data += data_length;
239  }
240  }
241 }
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:148
#define VARATT_IS_EXTERNAL_EXPANDED(PTR)
Definition: postgres.h:322
#define PointerGetDatum(X)
Definition: postgres.h:556
#define TTS_SHOULDFREE(slot)
Definition: tuptable.h:101
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define TTS_FLAG_SHOULDFREE
Definition: tuptable.h:100
MemoryContext tts_mcxt
Definition: tuptable.h:129
Datum * tts_values
Definition: tuptable.h:126
uint16 tts_flags
Definition: tuptable.h:119
bool * tts_isnull
Definition: tuptable.h:128
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
Size EOH_get_flat_size(ExpandedObjectHeader *eohptr)
Definition: expandeddatum.c:75
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uintptr_t Datum
Definition: postgres.h:367
void EOH_flatten_into(ExpandedObjectHeader *eohptr, void *result, Size allocated_size)
Definition: expandeddatum.c:81
size_t Size
Definition: c.h:466
#define DatumGetPointer(X)
Definition: postgres.h:549
#define att_addlength_datum(cur_offset, attlen, attdatum)
Definition: tupmacs.h:164
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
long val
Definition: informix.c:664

◆ tts_virtual_release()

static void tts_virtual_release ( TupleTableSlot slot)
static

Definition at line 102 of file execTuples.c.

Referenced by slot_deform_heap_tuple().

103 {
104 }

◆ TupleDescGetAttInMetadata()

AttInMetadata* TupleDescGetAttInMetadata ( TupleDesc  tupdesc)

Definition at line 2067 of file execTuples.c.

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, BlessTupleDesc(), fmgr_info(), getTypeInputInfo(), i, TupleDescData::natts, palloc(), palloc0(), AttInMetadata::tupdesc, and TupleDescAttr.

Referenced by bt_metap(), bt_page_stats(), build_pgstattuple_type(), connectby_text(), connectby_text_serial(), create_foreign_modify(), crosstab(), dblink_get_pkey(), get_crosstab_tuplestore(), hash_page_items(), libpqrcv_processTuples(), materializeResult(), pg_config(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), pg_stats_ext_mcvlist_items(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), pltcl_func_handler(), pltcl_init_tuple_store(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignScan(), prs_setup_firstcall(), show_all_settings(), storeRow(), ts_setup_firstcall(), tt_setup_firstcall(), and xpath_table().

2068 {
2069  int natts = tupdesc->natts;
2070  int i;
2071  Oid atttypeid;
2072  Oid attinfuncid;
2073  FmgrInfo *attinfuncinfo;
2074  Oid *attioparams;
2075  int32 *atttypmods;
2076  AttInMetadata *attinmeta;
2077 
2078  attinmeta = (AttInMetadata *) palloc(sizeof(AttInMetadata));
2079 
2080  /* "Bless" the tupledesc so that we can make rowtype datums with it */
2081  attinmeta->tupdesc = BlessTupleDesc(tupdesc);
2082 
2083  /*
2084  * Gather info needed later to call the "in" function for each attribute
2085  */
2086  attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo));
2087  attioparams = (Oid *) palloc0(natts * sizeof(Oid));
2088  atttypmods = (int32 *) palloc0(natts * sizeof(int32));
2089 
2090  for (i = 0; i < natts; i++)
2091  {
2092  Form_pg_attribute att = TupleDescAttr(tupdesc, i);
2093 
2094  /* Ignore dropped attributes */
2095  if (!att->attisdropped)
2096  {
2097  atttypeid = att->atttypid;
2098  getTypeInputInfo(atttypeid, &attinfuncid, &attioparams[i]);
2099  fmgr_info(attinfuncid, &attinfuncinfo[i]);
2100  atttypmods[i] = att->atttypmod;
2101  }
2102  }
2103  attinmeta->attinfuncs = attinfuncinfo;
2104  attinmeta->attioparams = attioparams;
2105  attinmeta->atttypmods = atttypmods;
2106 
2107  return attinmeta;
2108 }
Definition: fmgr.h:56
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
int32 * atttypmods
Definition: funcapi.h:47
unsigned int Oid
Definition: postgres_ext.h:31
Oid * attioparams
Definition: funcapi.h:44
signed int int32
Definition: c.h:355
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:126
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2052
TupleDesc tupdesc
Definition: funcapi.h:38
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:193
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
Definition: lsyscache.c:2751
void * palloc0(Size size)
Definition: mcxt.c:980
void * palloc(Size size)
Definition: mcxt.c:949
int i
FmgrInfo * attinfuncs
Definition: funcapi.h:41

Variable Documentation

◆ TTSOpsBufferHeapTuple

const TupleTableSlotOps TTSOpsBufferHeapTuple
Initial value:
= {
.base_slot_size = sizeof(BufferHeapTupleTableSlot),
.get_heap_tuple = tts_buffer_heap_get_heap_tuple,
.get_minimal_tuple = NULL,
.copy_heap_tuple = tts_buffer_heap_copy_heap_tuple,
.copy_minimal_tuple = tts_buffer_heap_copy_minimal_tuple
}
static void tts_buffer_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: execTuples.c:748
static HeapTuple tts_buffer_heap_get_heap_tuple(TupleTableSlot *slot)
Definition: execTuples.c:790
static MinimalTuple tts_buffer_heap_copy_minimal_tuple(TupleTableSlot *slot)
Definition: execTuples.c:816
static Datum tts_buffer_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: execTuples.c:678
static HeapTuple tts_buffer_heap_copy_heap_tuple(TupleTableSlot *slot)
Definition: execTuples.c:803
static void tts_buffer_heap_init(TupleTableSlot *slot)
Definition: execTuples.c:628
#define init()
struct BufferHeapTupleTableSlot BufferHeapTupleTableSlot
static void tts_buffer_heap_clear(TupleTableSlot *slot)
Definition: execTuples.c:638
static void tts_buffer_heap_getsomeattrs(TupleTableSlot *slot, int natts)
Definition: execTuples.c:668
static void tts_buffer_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:689
static void tts_buffer_heap_release(TupleTableSlot *slot)
Definition: execTuples.c:633

Definition at line 86 of file execTuples.c.

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

◆ TTSOpsHeapTuple

const TupleTableSlotOps TTSOpsHeapTuple
Initial value:
= {
.base_slot_size = sizeof(HeapTupleTableSlot),
.release = tts_heap_release,
.clear = tts_heap_clear,
.getsomeattrs = tts_heap_getsomeattrs,
.getsysattr = tts_heap_getsysattr,
.materialize = tts_heap_materialize,
.copyslot = tts_heap_copyslot,
.get_heap_tuple = tts_heap_get_heap_tuple,
.get_minimal_tuple = NULL,
.copy_heap_tuple = tts_heap_copy_heap_tuple,
.copy_minimal_tuple = tts_heap_copy_minimal_tuple
}
static void tts_heap_materialize(TupleTableSlot *slot)
Definition: execTuples.c:343
static void tts_heap_clear(TupleTableSlot *slot)
Definition: execTuples.c:303
static Datum tts_heap_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: execTuples.c:332
static HeapTuple tts_heap_get_heap_tuple(TupleTableSlot *slot)
Definition: execTuples.c:396
struct HeapTupleTableSlot HeapTupleTableSlot
static void tts_heap_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: execTuples.c:383
#define init()
static void tts_heap_release(TupleTableSlot *slot)
Definition: execTuples.c:298
static MinimalTuple tts_heap_copy_minimal_tuple(TupleTableSlot *slot)
Definition: execTuples.c:420
static void tts_heap_init(TupleTableSlot *slot)
Definition: execTuples.c:293
static void tts_heap_getsomeattrs(TupleTableSlot *slot, int natts)
Definition: execTuples.c:322
static HeapTuple tts_heap_copy_heap_tuple(TupleTableSlot *slot)
Definition: execTuples.c:408

Definition at line 84 of file execTuples.c.

Referenced by CatalogIndexInsert(), CheckOpSlotCompatibility(), compute_index_stats(), ExecInitForeignScan(), ExecInitGather(), ExecInitSetOp(), ExecuteCallStmt(), gather_merge_setup(), heapam_index_validate_scan(), slot_compile_deform(), table_slot_callbacks(), and tuplesort_begin_cluster().

◆ TTSOpsMinimalTuple

const TupleTableSlotOps TTSOpsMinimalTuple
Initial value:
= {
.base_slot_size = sizeof(MinimalTupleTableSlot),
.release = tts_minimal_release,
.getsomeattrs = tts_minimal_getsomeattrs,
.getsysattr = tts_minimal_getsysattr,
.materialize = tts_minimal_materialize,
.copyslot = tts_minimal_copyslot,
.get_heap_tuple = NULL,
.get_minimal_tuple = tts_minimal_get_minimal_tuple,
.copy_heap_tuple = tts_minimal_copy_heap_tuple,
.copy_minimal_tuple = tts_minimal_copy_minimal_tuple
}
static void tts_minimal_materialize(TupleTableSlot *slot)
Definition: execTuples.c:506
static void tts_minimal_getsomeattrs(TupleTableSlot *slot, int natts)
Definition: execTuples.c:488
static void tts_minimal_init(TupleTableSlot *slot)
Definition: execTuples.c:453
static HeapTuple tts_minimal_copy_heap_tuple(TupleTableSlot *slot)
Definition: execTuples.c:577
static MinimalTuple tts_minimal_get_minimal_tuple(TupleTableSlot *slot)
Definition: execTuples.c:566
static MinimalTuple tts_minimal_copy_minimal_tuple(TupleTableSlot *slot)
Definition: execTuples.c:588
#define init()
static Datum tts_minimal_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: execTuples.c:498
static void tts_minimal_release(TupleTableSlot *slot)
Definition: execTuples.c:465
struct MinimalTupleTableSlot MinimalTupleTableSlot
static void tts_minimal_clear(TupleTableSlot *slot)
Definition: execTuples.c:470
static void tts_minimal_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: execTuples.c:553

Definition at line 85 of file execTuples.c.

Referenced by afterTriggerInvokeEvents(), build_pertrans_for_aggref(), BuildTupleHashTableExt(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitHash(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitNamedTuplestoreScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), ExecInitWorkTableScan(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), find_hash_columns(), hashagg_recompile_expressions(), hypothetical_dense_rank_final(), init_sql_fcache(), ordered_set_startup(), RunFromStore(), and slot_compile_deform().

◆ TTSOpsVirtual

const TupleTableSlotOps TTSOpsVirtual
Initial value:
= {
.base_slot_size = sizeof(VirtualTupleTableSlot),
.release = tts_virtual_release,
.getsomeattrs = tts_virtual_getsomeattrs,
.getsysattr = tts_virtual_getsysattr,
.materialize = tts_virtual_materialize,
.copyslot = tts_virtual_copyslot,
.get_heap_tuple = NULL,
.get_minimal_tuple = NULL,
.copy_heap_tuple = tts_virtual_copy_heap_tuple,
.copy_minimal_tuple = tts_virtual_copy_minimal_tuple
}
static HeapTuple tts_virtual_copy_heap_tuple(TupleTableSlot *slot)
Definition: execTuples.c:268
struct VirtualTupleTableSlot VirtualTupleTableSlot
static void tts_virtual_getsomeattrs(TupleTableSlot *slot, int natts)
Definition: execTuples.c:130
static void tts_virtual_init(TupleTableSlot *slot)
Definition: execTuples.c:97
static Datum tts_virtual_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: execTuples.c:136
#define init()
static void tts_virtual_materialize(TupleTableSlot *slot)
Definition: execTuples.c:151
static MinimalTuple tts_virtual_copy_minimal_tuple(TupleTableSlot *slot)
Definition: execTuples.c:278
static void tts_virtual_clear(TupleTableSlot *slot)
Definition: execTuples.c:107
static void tts_virtual_copyslot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: execTuples.c:244
static void tts_virtual_release(TupleTableSlot *slot)
Definition: execTuples.c:102

Definition at line 83 of file execTuples.c.

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