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:458
void(* rStartup)(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: dest.h:121
void * palloc(Size size)
Definition: mcxt.c:949
DestReceiver * dest
Definition: executor.h:459

◆ 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(), 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_ls_dir_files(), 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_timezone_names(), 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:1772
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_print_tuples(), 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:48
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, Datum *values, bool *isnull)
Definition: heaptuple.c:1020
Oid * attioparams
Definition: funcapi.h:45
void pfree(void *pointer)
Definition: mcxt.c:1056
TupleDesc tupdesc
Definition: funcapi.h:39
uintptr_t Datum
Definition: postgres.h:367
Datum InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1531
static Datum values[MAXATTR]
Definition: bootstrap.c:167
void * palloc(Size size)
Definition: mcxt.c:949
int i
FmgrInfo * attinfuncs
Definition: funcapi.h:42

◆ 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:183
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:118
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:425
Datum * tts_values
Definition: tuptable.h:126
TupleTableSlot * slot
Definition: executor.h:458
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:459
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:458
void pfree(void *pointer)
Definition: mcxt.c:1056
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1224
void(* rShutdown)(DestReceiver *self)
Definition: dest.h:124
DestReceiver * dest
Definition: executor.h:459

◆ ExecAllocTableSlot()

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

Definition at line 1141 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

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

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

◆ 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(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), hypothetical_dense_rank_final(), IndexCheckExclusion(), RelationFindReplTupleSeq(), RI_Initial_Check(), RunFromStore(), systable_endscan(), systable_endscan_ordered(), table_index_fetch_tuple_check(), tuplesort_end(), unique_key_recheck(), validateCheckConstraint(), validateDomainConstraint(), and validateForeignKeyConstraint().

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

◆ ExecFetchSlotHeapTuple()

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

Definition at line 1614 of file execTuples.c.

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

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

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

◆ ExecFetchSlotHeapTupleDatum()

Datum ExecFetchSlotHeapTupleDatum ( TupleTableSlot slot)

Definition at line 1693 of file execTuples.c.

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

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

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

◆ ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot slot,
bool shouldFree 
)

Definition at line 1662 of file execTuples.c.

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

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

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

◆ ExecForceStoreHeapTuple()

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

Definition at line 1439 of file execTuples.c.

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

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

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

◆ ExecForceStoreMinimalTuple()

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

Definition at line 1482 of file execTuples.c.

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

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

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

◆ 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:942
const TupleTableSlotOps * resultops
Definition: execnodes.h:1015
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:978
bool resultopsset
Definition: execnodes.h:1023
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1141
TupleDesc ps_ResultTupleDesc
Definition: execnodes.h:977
List * es_tupleTable
Definition: execnodes.h:552
bool resultopsfixed
Definition: execnodes.h:1019

◆ ExecInitResultTupleSlotTL()

void ExecInitResultTupleSlotTL ( PlanState planstate,
const TupleTableSlotOps tts_ops 
)

Definition at line 1769 of file execTuples.c.

References ExecInitResultSlot(), and ExecInitResultTypeTL().

Referenced by ExecInitAgg(), ExecInitAppend(), ExecInitCustomScan(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitResult(), ExecInitSetOp(), ExecInitSort(), ExecInitUnique(), and ExecInitWindowAgg().

1771 {
1772  ExecInitResultTypeTL(planstate);
1773  ExecInitResultSlot(planstate, tts_ops);
1774 }
void ExecInitResultTypeTL(PlanState *planstate)
Definition: execTuples.c:1725
void ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1749

◆ 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:1334
PlanState ps
Definition: execnodes.h:1331
const TupleTableSlotOps * scanops
Definition: execnodes.h:1012
TupleTableSlot * ExecAllocTableSlot(List **tupleTable, TupleDesc desc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1141
List * es_tupleTable
Definition: execnodes.h:552
TupleDesc scandesc
Definition: execnodes.h:987
bool scanopsfixed
Definition: execnodes.h:1016
bool scanopsset
Definition: execnodes.h:1020

◆ ExecResetTupleTable()

void ExecResetTupleTable ( List tupleTable,
bool  shouldFree 
)

Definition at line 1161 of file execTuples.c.

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

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

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

◆ ExecSetSlotDescriptor()

void ExecSetSlotDescriptor ( TupleTableSlot slot,
TupleDesc  tupdesc 
)

Definition at line 1259 of file execTuples.c.

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

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

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

◆ ExecStoreAllNullTuple()

TupleTableSlot* ExecStoreAllNullTuple ( TupleTableSlot slot)

Definition at line 1546 of file execTuples.c.

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

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

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

◆ ExecStoreBufferHeapTuple()

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

Definition at line 1362 of file execTuples.c.

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

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

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

◆ ExecStoreHeapTuple()

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

Definition at line 1322 of file execTuples.c.

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

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

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

◆ ExecStoreHeapTupleDatum()

void ExecStoreHeapTupleDatum ( Datum  data,
TupleTableSlot slot 
)

Definition at line 1576 of file execTuples.c.

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

Referenced by EvalPlanQualFetchRowMark().

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

◆ ExecStoreMinimalTuple()

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

Definition at line 1416 of file execTuples.c.

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

Referenced by agg_retrieve_hash_table(), ExecParallelScanHashBucket(), ExecScanHashBucket(), ExecScanHashTableForUnmatched(), findPartialMatch(), setop_retrieve_hash_table(), tts_minimal_copyslot(), TupleHashTableHash(), TupleHashTableMatch(), tuplesort_gettupleslot(), and tuplestore_gettupleslot().

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

◆ ExecStorePinnedBufferHeapTuple()

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

Definition at line 1388 of file execTuples.c.

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

Referenced by heapam_fetch_row_version(), and heapam_tuple_lock().

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

◆ ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot slot)

Definition at line 1522 of file execTuples.c.

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

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

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

◆ 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:525
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:1075
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:44
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:275
Definition: nodes.h:525
char * resname
Definition: primnodes.h:1395
bool resjunk
Definition: primnodes.h:1400
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:1085
#define lfirst(lc)
Definition: pg_list.h:190
Expr * expr
Definition: primnodes.h:1393
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:200
#define lfirst(lc)
Definition: pg_list.h:190
Oid tdtypeid
Definition: tupdesc.h:82
#define NameStr(name)
Definition: c.h:610

◆ 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:1652
#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:442
#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:467
#define MAXALIGN(LEN)
Definition: c.h:686
#define PinTupleDesc(tupdesc)
Definition: tupdesc.h:116
AttrNumber tts_nvalid
Definition: tuptable.h:121
size_t base_slot_size
Definition: tuptable.h:138

◆ slot_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:146
bits8 t_bits[FLEXIBLE_ARRAY_MEMBER]
Definition: htup_details.h:177
#define att_isnull(ATT, BITS)
Definition: tupmacs.h:23
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define Min(x, y)
Definition: c.h:905
Datum * tts_values
Definition: tuptable.h:126
#define fetchatt(A, T)
Definition: tupmacs.h:39
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:200
unsigned int uint32
Definition: c.h:359
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:174
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
uint8 bits8
Definition: c.h:366
uintptr_t Datum
Definition: postgres.h:367
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition: tupmacs.h:124
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:733
void(* getsomeattrs)(TupleTableSlot *slot, int natts)
Definition: tuptable.h:161
void slot_getmissingattrs(TupleTableSlot *slot, int startAttNum, int lastAttNum)
Definition: execTuples.c:1838
#define elog(elevel,...)
Definition: elog.h:228
#define unlikely(x)
Definition: c.h:208
AttrNumber tts_nvalid
Definition: tuptable.h:121

◆ 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:3365
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1338
uint16 tts_flags
Definition: tuptable.h:119
#define Assert(condition)
Definition: c.h:733
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
#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:733
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:733
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:733
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
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:733
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:733
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:733
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:207
#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:3365
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:733
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
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:3365
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:733
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
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:3403

◆ 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:733

◆ 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:733

◆ 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:733

◆ 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:733

◆ 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:733
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:733

◆ 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:228

◆ 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:733
#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:733
#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:208
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:733

◆ 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:733

◆ 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:733
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:228

◆ 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:228

◆ 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:146
#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:200
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:467
#define DatumGetPointer(X)
Definition: postgres.h:549
#define att_addlength_datum(cur_offset, attlen, attdatum)
Definition: tupmacs.h:162
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:796
long val
Definition: informix.c:684

◆ 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_items(), bt_page_items_bytea(), 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:48
unsigned int Oid
Definition: postgres_ext.h:31
Oid * attioparams
Definition: funcapi.h:45
signed int int32
Definition: c.h:347
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:124
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
Definition: execTuples.c:2052
TupleDesc tupdesc
Definition: funcapi.h:39
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:200
void getTypeInputInfo(Oid type, Oid *typInput, Oid *typIOParam)
Definition: lsyscache.c:2641
void * palloc0(Size size)
Definition: mcxt.c:980
void * palloc(Size size)
Definition: mcxt.c:949
int i
FmgrInfo * attinfuncs
Definition: funcapi.h:42

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(), check_sql_fn_retval(), ExecInitAgg(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitHash(), ExecInitMaterial(), ExecInitNamedTuplestoreScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), ExecInitWorkTableScan(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), find_hash_columns(), hypothetical_dense_rank_final(), 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().