#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:

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)

TupleTableSlot *	MakeTupleTableSlot (TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)

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

void	ExecResetTupleTable (List *tupleTable, bool shouldFree)

TupleTableSlot *	MakeSingleTupleTableSlot (TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)

void	ExecDropSingleTupleTableSlot (TupleTableSlot *slot)

void	ExecSetSlotDescriptor (TupleTableSlot *slot, TupleDesc tupdesc)

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

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

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

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

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

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

TupleTableSlot *	ExecStoreVirtualTuple (TupleTableSlot *slot)

TupleTableSlot *	ExecStoreAllNullTuple (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)

TupleTableSlot *	ExecInitExtraTupleSlot (EState estate, TupleDesc tupledesc, const TupleTableSlotOps tts_ops)

TupleTableSlot *	ExecInitNullTupleSlot (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)

AttInMetadata *	TupleDescGetAttInMetadata (TupleDesc tupdesc)

HeapTuple	BuildTupleFromCStrings (AttInMetadata attinmeta, char *values)

Datum	HeapTupleHeaderGetDatum (HeapTupleHeader tuple)

TupOutputState *	begin_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().

 {
     TupOutputState *tstate;
 
     tstate = (TupOutputState *) palloc(sizeof(TupOutputState));
 
     tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
     tstate->dest = dest;
 
     tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
 
     return tstate;
 }

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

 {
     if (tupdesc->tdtypeid == RECORDOID &&
         tupdesc->tdtypmod < 0)
         assign_record_type_typmod(tupdesc);
 
     return tupdesc;             /* just for notational convenience */
 }

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

 {
     TupleDesc   tupdesc = attinmeta->tupdesc;
     int         natts = tupdesc->natts;
     Datum      *dvalues;
     bool       *nulls;
     int         i;
     HeapTuple   tuple;
 
     dvalues = (Datum *) palloc(natts * sizeof(Datum));
     nulls = (bool *) palloc(natts * sizeof(bool));
 
     /*
      * Call the "in" function for each non-dropped attribute, even for nulls,
      * to support domains.
      */
     for (i = 0; i < natts; i++)
     {
         if (!TupleDescAttr(tupdesc, i)->attisdropped)
         {
             /* Non-dropped attributes */
             dvalues[i] = InputFunctionCall(&attinmeta->attinfuncs[i],
                                            values[i],
                                            attinmeta->attioparams[i],
                                            attinmeta->atttypmods[i]);
             if (values[i] != NULL)
                 nulls[i] = false;
             else
                 nulls[i] = true;
         }
         else
         {
             /* Handle dropped attributes by setting to NULL */
             dvalues[i] = (Datum) 0;
             nulls[i] = true;
         }
     }
 
     /*
      * Form a tuple
      */
     tuple = heap_form_tuple(tupdesc, dvalues, nulls);
 
     /*
      * Release locally palloc'd space.  XXX would probably be good to pfree
      * values of pass-by-reference datums, as well.
      */
     pfree(dvalues);
     pfree(nulls);
 
     return tuple;
 }

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

 {
     Datum       values[1];
     bool        isnull[1] = {false};
 
     while (*txt)
     {
         const char *eol;
         int         len;
 
         eol = strchr(txt, '\n');
         if (eol)
         {
             len = eol - txt;
             eol++;
         }
         else
         {
             len = strlen(txt);
             eol = txt + len;
         }
 
         values[0] = PointerGetDatum(cstring_to_text_with_len(txt, len));
         do_tup_output(tstate, values, isnull);
         pfree(DatumGetPointer(values[0]));
         txt = eol;
     }
 }

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

 {
     TupleTableSlot *slot = tstate->slot;
     int         natts = slot->tts_tupleDescriptor->natts;
 
     /* make sure the slot is clear */
     ExecClearTuple(slot);
 
     /* insert data */
     memcpy(slot->tts_values, values, natts * sizeof(Datum));
     memcpy(slot->tts_isnull, isnull, natts * sizeof(bool));
 
     /* mark slot as containing a virtual tuple */
     ExecStoreVirtualTuple(slot);
 
     /* send the tuple to the receiver */
     (void) tstate->dest->receiveSlot(slot, tstate->dest);
 
     /* clean up */
     ExecClearTuple(slot);
 }

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

 {
     tstate->dest->rShutdown(tstate->dest);
     /* note that destroying the dest is not ours to do */
     ExecDropSingleTupleTableSlot(tstate->slot);
     pfree(tstate);
 }

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

 {
     TupleTableSlot *slot = MakeTupleTableSlot(desc, tts_ops);
 
     *tupleTable = lappend(*tupleTable, slot);
 
     return slot;
 }

◆ ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL ( List * targetList )

Definition at line 1920 of file execTuples.c.

References ExecTypeFromTLInternal().

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

 {
     return ExecTypeFromTLInternal(targetList, true);
 }

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

 {
     /* This should match ExecResetTupleTable's processing of one slot */
     Assert(IsA(slot, TupleTableSlot));
     ExecClearTuple(slot);
     slot->tts_ops->release(slot);
     if (slot->tts_tupleDescriptor)
         ReleaseTupleDesc(slot->tts_tupleDescriptor);
     if (!TTS_FIXED(slot))
     {
         if (slot->tts_values)
             pfree(slot->tts_values);
         if (slot->tts_isnull)
             pfree(slot->tts_isnull);
     }
     pfree(slot);
 }

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

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!TTS_EMPTY(slot));
 
     /* Materialize the tuple so that the slot "owns" it, if requested. */
     if (materialize)
         slot->tts_ops->materialize(slot);
 
     if (slot->tts_ops->get_heap_tuple == NULL)
     {
         if (shouldFree)
             *shouldFree = true;
         return slot->tts_ops->copy_heap_tuple(slot);
     }
     else
     {
         if (shouldFree)
             *shouldFree = false;
         return slot->tts_ops->get_heap_tuple(slot);
     }
 }

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

 {
     HeapTuple   tup;
     TupleDesc   tupdesc;
     bool        shouldFree;
     Datum       ret;
 
     /* Fetch slot's contents in regular-physical-tuple form */
     tup = ExecFetchSlotHeapTuple(slot, false, &shouldFree);
     tupdesc = slot->tts_tupleDescriptor;
 
     /* Convert to Datum form */
     ret = heap_copy_tuple_as_datum(tup, tupdesc);
 
     if (shouldFree)
         pfree(tup);
 
     return ret;
 }

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

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!TTS_EMPTY(slot));
 
     if (slot->tts_ops->get_minimal_tuple)
     {
         if (shouldFree)
             *shouldFree = false;
         return slot->tts_ops->get_minimal_tuple(slot);
     }
     else
     {
         if (shouldFree)
             *shouldFree = true;
         return slot->tts_ops->copy_minimal_tuple(slot);
     }
 }

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

 {
     if (TTS_IS_HEAPTUPLE(slot))
     {
         ExecStoreHeapTuple(tuple, slot, shouldFree);
     }
     else if (TTS_IS_BUFFERTUPLE(slot))
     {
         MemoryContext oldContext;
         BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
 
         ExecClearTuple(slot);
         slot->tts_flags &= ~TTS_FLAG_EMPTY;
         oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
         bslot->base.tuple = heap_copytuple(tuple);
         slot->tts_flags |= TTS_FLAG_SHOULDFREE;
         MemoryContextSwitchTo(oldContext);
 
         if (shouldFree)
             pfree(tuple);
     }
     else
     {
         ExecClearTuple(slot);
         heap_deform_tuple(tuple, slot->tts_tupleDescriptor,
                           slot->tts_values, slot->tts_isnull);
         ExecStoreVirtualTuple(slot);
 
         if (shouldFree)
         {
             ExecMaterializeSlot(slot);
             pfree(tuple);
         }
     }
 }

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

 {
     if (TTS_IS_MINIMALTUPLE(slot))
     {
         tts_minimal_store_tuple(slot, mtup, shouldFree);
     }
     else
     {
         HeapTupleData htup;
 
         ExecClearTuple(slot);
 
         htup.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
         htup.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
         heap_deform_tuple(&htup, slot->tts_tupleDescriptor,
                           slot->tts_values, slot->tts_isnull);
         ExecStoreVirtualTuple(slot);
 
         if (shouldFree)
         {
             ExecMaterializeSlot(slot);
             pfree(mtup);
         }
     }
 }

◆ ExecInitExtraTupleSlot()

TupleTableSlot* ExecInitExtraTupleSlot	(	EState *	estate,
		TupleDesc	tupledesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1801 of file execTuples.c.

References EState::es_tupleTable, and ExecAllocTableSlot().

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_update(), build_pertrans_for_aggref(), ExecGetReturningSlot(), ExecGetTriggerNewSlot(), ExecGetTriggerOldSlot(), ExecInitAgg(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHashJoin(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNullTupleSlot(), ExecInitPartitionInfo(), ExecInitSubPlan(), ExecInitWholeRowVar(), ExecInitWindowAgg(), gather_merge_setup(), and InitPlan().

 {
     return ExecAllocTableSlot(&estate->es_tupleTable, tupledesc, tts_ops);
 }

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

 {
     TupleTableSlot *slot = ExecInitExtraTupleSlot(estate, tupType, tts_ops);
 
     return ExecStoreAllNullTuple(slot);
 }

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

 {
     TupleTableSlot *slot;
 
     slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
                               planstate->ps_ResultTupleDesc, tts_ops);
     planstate->ps_ResultTupleSlot = slot;
 
     planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
     planstate->resultops = tts_ops;
     planstate->resultopsset = true;
 }

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

 {
     ExecInitResultTypeTL(planstate);
     ExecInitResultSlot(planstate, tts_ops);
 }

◆ ExecInitResultTypeTL()

void ExecInitResultTypeTL ( PlanState * planstate )

Definition at line 1725 of file execTuples.c.

References ExecTypeFromTL(), PlanState::plan, PlanState::ps_ResultTupleDesc, and Plan::targetlist.

Referenced by ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitRecursiveUnion(), ExecInitResultTupleSlotTL(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecInitWorkTableScan().

 {
     TupleDesc   tupDesc = ExecTypeFromTL(planstate->plan->targetlist);
 
     planstate->ps_ResultTupleDesc = tupDesc;
 }

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

 {
     scanstate->ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable,
                                                      tupledesc, tts_ops);
     scanstate->ps.scandesc = tupledesc;
     scanstate->ps.scanopsfixed = tupledesc != NULL;
     scanstate->ps.scanops = tts_ops;
     scanstate->ps.scanopsset = true;
 }

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

 {
     ListCell   *lc;
 
     foreach(lc, tupleTable)
     {
         TupleTableSlot *slot = lfirst_node(TupleTableSlot, lc);
 
         /* Always release resources and reset the slot to empty */
         ExecClearTuple(slot);
         slot->tts_ops->release(slot);
         if (slot->tts_tupleDescriptor)
         {
             ReleaseTupleDesc(slot->tts_tupleDescriptor);
             slot->tts_tupleDescriptor = NULL;
         }
 
         /* If shouldFree, release memory occupied by the slot itself */
         if (shouldFree)
         {
             if (!TTS_FIXED(slot))
             {
                 if (slot->tts_values)
                     pfree(slot->tts_values);
                 if (slot->tts_isnull)
                     pfree(slot->tts_isnull);
             }
             pfree(slot);
         }
     }
 
     /* If shouldFree, release the list structure */
     if (shouldFree)
         list_free(tupleTable);
 }

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

 {
     Assert(!TTS_FIXED(slot));
 
     /* For safety, make sure slot is empty before changing it */
     ExecClearTuple(slot);
 
     /*
      * Release any old descriptor.  Also release old Datum/isnull arrays if
      * present (we don't bother to check if they could be re-used).
      */
     if (slot->tts_tupleDescriptor)
         ReleaseTupleDesc(slot->tts_tupleDescriptor);
 
     if (slot->tts_values)
         pfree(slot->tts_values);
     if (slot->tts_isnull)
         pfree(slot->tts_isnull);
 
     /*
      * Install the new descriptor; if it's refcounted, bump its refcount.
      */
     slot->tts_tupleDescriptor = tupdesc;
     PinTupleDesc(tupdesc);
 
     /*
      * Allocate Datum/isnull arrays of the appropriate size.  These must have
      * the same lifetime as the slot, so allocate in the slot's own context.
      */
     slot->tts_values = (Datum *)
         MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(Datum));
     slot->tts_isnull = (bool *)
         MemoryContextAlloc(slot->tts_mcxt, tupdesc->natts * sizeof(bool));
 }

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

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
 
     /* Clear any old contents */
     ExecClearTuple(slot);
 
     /*
      * Fill all the columns of the virtual tuple with nulls
      */
     MemSet(slot->tts_values, 0,
            slot->tts_tupleDescriptor->natts * sizeof(Datum));
     memset(slot->tts_isnull, true,
            slot->tts_tupleDescriptor->natts * sizeof(bool));
 
     return ExecStoreVirtualTuple(slot);
 }

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

 {
     /*
      * sanity checks
      */
     Assert(tuple != NULL);
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
     Assert(BufferIsValid(buffer));
 
     if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
         elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
     tts_buffer_heap_store_tuple(slot, tuple, buffer, false);
 
     slot->tts_tableOid = tuple->t_tableOid;
 
     return slot;
 }

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

 {
     /*
      * sanity checks
      */
     Assert(tuple != NULL);
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
 
     if (unlikely(!TTS_IS_HEAPTUPLE(slot)))
         elog(ERROR, "trying to store a heap tuple into wrong type of slot");
     tts_heap_store_tuple(slot, tuple, shouldFree);
 
     slot->tts_tableOid = tuple->t_tableOid;
 
     return slot;
 }

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

 {
     HeapTupleData tuple = {0};
     HeapTupleHeader td;
 
     td = DatumGetHeapTupleHeader(data);
 
     tuple.t_len = HeapTupleHeaderGetDatumLength(td);
     tuple.t_self = td->t_ctid;
     tuple.t_data = td;
 
     ExecClearTuple(slot);
 
     heap_deform_tuple(&tuple, slot->tts_tupleDescriptor,
                       slot->tts_values, slot->tts_isnull);
     ExecStoreVirtualTuple(slot);
 }

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

 {
     /*
      * sanity checks
      */
     Assert(mtup != NULL);
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
 
     if (unlikely(!TTS_IS_MINIMALTUPLE(slot)))
         elog(ERROR, "trying to store a minimal tuple into wrong type of slot");
     tts_minimal_store_tuple(slot, mtup, shouldFree);
 
     return slot;
 }

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

 {
     /*
      * sanity checks
      */
     Assert(tuple != NULL);
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
     Assert(BufferIsValid(buffer));
 
     if (unlikely(!TTS_IS_BUFFERTUPLE(slot)))
         elog(ERROR, "trying to store an on-disk heap tuple into wrong type of slot");
     tts_buffer_heap_store_tuple(slot, tuple, buffer, true);
 
     slot->tts_tableOid = tuple->t_tableOid;
 
     return slot;
 }

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

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
     Assert(TTS_EMPTY(slot));
 
     slot->tts_flags &= ~TTS_FLAG_EMPTY;
     slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
 
     return slot;
 }

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

 {
     TupleDesc   typeInfo;
     ListCell   *lc;
     int         cur_resno = 1;
 
     typeInfo = CreateTemplateTupleDesc(list_length(exprList));
 
     foreach(lc, exprList)
     {
         Node       *e = lfirst(lc);
 
         TupleDescInitEntry(typeInfo,
                            cur_resno,
                            NULL,
                            exprType(e),
                            exprTypmod(e),
                            0);
         TupleDescInitEntryCollation(typeInfo,
                                     cur_resno,
                                     exprCollation(e));
         cur_resno++;
     }
 
     return typeInfo;
 }

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

 {
     return ExecTypeFromTLInternal(targetList, false);
 }

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

 {
     TupleDesc   typeInfo;
     ListCell   *l;
     int         len;
     int         cur_resno = 1;
 
     if (skipjunk)
         len = ExecCleanTargetListLength(targetList);
     else
         len = ExecTargetListLength(targetList);
     typeInfo = CreateTemplateTupleDesc(len);
 
     foreach(l, targetList)
     {
         TargetEntry *tle = lfirst(l);
 
         if (skipjunk && tle->resjunk)
             continue;
         TupleDescInitEntry(typeInfo,
                            cur_resno,
                            tle->resname,
                            exprType((Node *) tle->expr),
                            exprTypmod((Node *) tle->expr),
                            0);
         TupleDescInitEntryCollation(typeInfo,
                                     cur_resno,
                                     exprCollation((Node *) tle->expr));
         cur_resno++;
     }
 
     return typeInfo;
 }

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

 {
     bool        modified = false;
     int         colno = 0;
     ListCell   *lc;
 
     foreach(lc, namesList)
     {
         char       *cname = strVal(lfirst(lc));
         Form_pg_attribute attr;
 
         /* Guard against too-long names list */
         if (colno >= typeInfo->natts)
             break;
         attr = TupleDescAttr(typeInfo, colno);
         colno++;
 
         /* Ignore empty aliases (these must be for dropped columns) */
         if (cname[0] == '\0')
             continue;
 
         /* Change tupdesc only if alias is actually different */
         if (strcmp(cname, NameStr(attr->attname)) != 0)
         {
             namestrcpy(&(attr->attname), cname);
             modified = true;
         }
     }
 
     /* If we modified the tupdesc, it's now a new record type */
     if (modified)
     {
         typeInfo->tdtypeid = RECORDOID;
         typeInfo->tdtypmod = -1;
     }
 }

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

 {
     Datum       result;
     TupleDesc   tupDesc;
 
     /* No work if there are no external TOAST pointers in the tuple */
     if (!HeapTupleHeaderHasExternal(tuple))
         return PointerGetDatum(tuple);
 
     /* Use the type data saved by heap_form_tuple to look up the rowtype */
     tupDesc = lookup_rowtype_tupdesc(HeapTupleHeaderGetTypeId(tuple),
                                      HeapTupleHeaderGetTypMod(tuple));
 
     /* And do the flattening */
     result = toast_flatten_tuple_to_datum(tuple,
                                           HeapTupleHeaderGetDatumLength(tuple),
                                           tupDesc);
 
     ReleaseTupleDesc(tupDesc);
 
     return result;
 }

◆ MakeSingleTupleTableSlot()

TupleTableSlot* MakeSingleTupleTableSlot	(	TupleDesc	tupdesc,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1208 of file execTuples.c.

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTableExt(), CatalogIndexInsert(), compute_index_stats(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitPartitionDispatchInfo(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), heapam_index_validate_scan(), hypothetical_dense_rank_final(), init_sql_fcache(), ordered_set_startup(), RI_Initial_Check(), RI_PartitionRemove_Check(), RunFromStore(), table_slot_create(), and tuplesort_begin_cluster().

 {
     TupleTableSlot *slot = MakeTupleTableSlot(tupdesc, tts_ops);
 
     return slot;
 }

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

 {
     Size        basesz,
                 allocsz;
     TupleTableSlot *slot;
 
     basesz = tts_ops->base_slot_size;
 
     /*
      * When a fixed descriptor is specified, we can reduce overhead by
      * allocating the entire slot in one go.
      */
     if (tupleDesc)
         allocsz = MAXALIGN(basesz) +
             MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
             MAXALIGN(tupleDesc->natts * sizeof(bool));
     else
         allocsz = basesz;
 
     slot = palloc0(allocsz);
     /* const for optimization purposes, OK to modify at allocation time */
     *((const TupleTableSlotOps **) &slot->tts_ops) = tts_ops;
     slot->type = T_TupleTableSlot;
     slot->tts_flags |= TTS_FLAG_EMPTY;
     if (tupleDesc != NULL)
         slot->tts_flags |= TTS_FLAG_FIXED;
     slot->tts_tupleDescriptor = tupleDesc;
     slot->tts_mcxt = CurrentMemoryContext;
     slot->tts_nvalid = 0;
 
     if (tupleDesc != NULL)
     {
         slot->tts_values = (Datum *)
             (((char *) slot)
              + MAXALIGN(basesz));
         slot->tts_isnull = (bool *)
             (((char *) slot)
              + MAXALIGN(basesz)
              + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
 
         PinTupleDesc(tupleDesc);
     }
 
     /*
      * And allow slot type specific initialization.
      */
     slot->tts_ops->init(slot);
 
     return slot;
 }

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

 {
     TupleDesc   tupleDesc = slot->tts_tupleDescriptor;
     Datum      *values = slot->tts_values;
     bool       *isnull = slot->tts_isnull;
     HeapTupleHeader tup = tuple->t_data;
     bool        hasnulls = HeapTupleHasNulls(tuple);
     int         attnum;
     char       *tp;             /* ptr to tuple data */
     uint32      off;            /* offset in tuple data */
     bits8      *bp = tup->t_bits;   /* ptr to null bitmap in tuple */
     bool        slow;           /* can we use/set attcacheoff? */
 
     /* We can only fetch as many attributes as the tuple has. */
     natts = Min(HeapTupleHeaderGetNatts(tuple->t_data), natts);
 
     /*
      * Check whether the first call for this tuple, and initialize or restore
      * loop state.
      */
     attnum = slot->tts_nvalid;
     if (attnum == 0)
     {
         /* Start from the first attribute */
         off = 0;
         slow = false;
     }
     else
     {
         /* Restore state from previous execution */
         off = *offp;
         slow = TTS_SLOW(slot);
     }
 
     tp = (char *) tup + tup->t_hoff;
 
     for (; attnum < natts; attnum++)
     {
         Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
 
         if (hasnulls && att_isnull(attnum, bp))
         {
             values[attnum] = (Datum) 0;
             isnull[attnum] = true;
             slow = true;        /* can't use attcacheoff anymore */
             continue;
         }
 
         isnull[attnum] = false;
 
         if (!slow && thisatt->attcacheoff >= 0)
             off = thisatt->attcacheoff;
         else if (thisatt->attlen == -1)
         {
             /*
              * We can only cache the offset for a varlena attribute if the
              * offset is already suitably aligned, so that there would be no
              * pad bytes in any case: then the offset will be valid for either
              * an aligned or unaligned value.
              */
             if (!slow &&
                 off == att_align_nominal(off, thisatt->attalign))
                 thisatt->attcacheoff = off;
             else
             {
                 off = att_align_pointer(off, thisatt->attalign, -1,
                                         tp + off);
                 slow = true;
             }
         }
         else
         {
             /* not varlena, so safe to use att_align_nominal */
             off = att_align_nominal(off, thisatt->attalign);
 
             if (!slow)
                 thisatt->attcacheoff = off;
         }
 
         values[attnum] = fetchatt(thisatt, tp + off);
 
         off = att_addlength_pointer(off, thisatt->attlen, tp + off);
 
         if (thisatt->attlen <= 0)
             slow = true;        /* can't use attcacheoff anymore */
     }
 
     /*
      * Save state for next execution
      */
     slot->tts_nvalid = attnum;
     *offp = off;
     if (slow)
         slot->tts_flags |= TTS_FLAG_SLOW;
     else
         slot->tts_flags &= ~TTS_FLAG_SLOW;
 }

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

 {
     AttrMissing *attrmiss = NULL;
 
     if (slot->tts_tupleDescriptor->constr)
         attrmiss = slot->tts_tupleDescriptor->constr->missing;
 
     if (!attrmiss)
     {
         /* no missing values array at all, so just fill everything in as NULL */
         memset(slot->tts_values + startAttNum, 0,
                (lastAttNum - startAttNum) * sizeof(Datum));
         memset(slot->tts_isnull + startAttNum, 1,
                (lastAttNum - startAttNum) * sizeof(bool));
     }
     else
     {
         int         missattnum;
 
         /* if there is a missing values array we must process them one by one */
         for (missattnum = startAttNum;
              missattnum < lastAttNum;
              missattnum++)
         {
             slot->tts_values[missattnum] = attrmiss[missattnum].am_value;
             slot->tts_isnull[missattnum] = !attrmiss[missattnum].am_present;
         }
     }
 }

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

 {
     /* Check for caller errors */
     Assert(slot->tts_nvalid < attnum);  /* checked in slot_getsomeattrs */
     Assert(attnum > 0);
 
     if (unlikely(attnum > slot->tts_tupleDescriptor->natts))
         elog(ERROR, "invalid attribute number %d", attnum);
 
     /* Fetch as many attributes as possible from the underlying tuple. */
     slot->tts_ops->getsomeattrs(slot, attnum);
 
     /*
      * If the underlying tuple doesn't have enough attributes, tuple
      * descriptor must have the missing attributes.
      */
     if (unlikely(slot->tts_nvalid < attnum))
     {
         slot_getmissingattrs(slot, slot->tts_nvalid, attnum);
         slot->tts_nvalid = attnum;
     }
 }

◆ 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.

Functions

Variables

Function Documentation

◆ begin_tup_output_tupdesc()

◆ BlessTupleDesc()

◆ BuildTupleFromCStrings()

◆ do_text_output_multiline()

◆ do_tup_output()

◆ end_tup_output()

◆ ExecAllocTableSlot()

◆ ExecCleanTypeFromTL()

◆ ExecDropSingleTupleTableSlot()

◆ ExecFetchSlotHeapTuple()

◆ ExecFetchSlotHeapTupleDatum()

◆ ExecFetchSlotMinimalTuple()

◆ ExecForceStoreHeapTuple()

◆ ExecForceStoreMinimalTuple()

◆ ExecInitExtraTupleSlot()

◆ ExecInitNullTupleSlot()

◆ ExecInitResultSlot()

◆ ExecInitResultTupleSlotTL()

◆ ExecInitResultTypeTL()

◆ ExecInitScanTupleSlot()

◆ ExecResetTupleTable()

◆ ExecSetSlotDescriptor()

◆ ExecStoreAllNullTuple()

◆ ExecStoreBufferHeapTuple()

◆ ExecStoreHeapTuple()

◆ ExecStoreHeapTupleDatum()

◆ ExecStoreMinimalTuple()

◆ ExecStorePinnedBufferHeapTuple()

◆ ExecStoreVirtualTuple()

◆ ExecTypeFromExprList()

◆ ExecTypeFromTL()

◆ ExecTypeFromTLInternal()

◆ ExecTypeSetColNames()

◆ HeapTupleHeaderGetDatum()

◆ MakeSingleTupleTableSlot()

◆ MakeTupleTableSlot()

◆ slot_deform_heap_tuple()

◆ slot_getmissingattrs()

◆ slot_getsomeattrs_int()

◆ 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_buffer_heap_store_tuple()

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

◆ tts_heap_store_tuple()

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

◆ tts_minimal_store_tuple()

◆ tts_virtual_clear()

◆ tts_virtual_copy_heap_tuple()

◆ tts_virtual_copy_minimal_tuple()

◆ tts_virtual_copyslot()

◆ tts_virtual_getsomeattrs()