#include "postgres.h"
#include "access/htup_details.h"
#include "access/tuptoaster.h"
#include "funcapi.h"
#include "catalog/pg_type.h"
#include "nodes/nodeFuncs.h"
#include "storage/bufmgr.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/typcache.h"

Include dependency graph for execTuples.c:

Functions
static TupleDesc	ExecTypeFromTLInternal (List *targetList, bool hasoid, bool skipjunk)

TupleTableSlot *	MakeTupleTableSlot (TupleDesc tupleDesc)

TupleTableSlot *	ExecAllocTableSlot (List **tupleTable, TupleDesc desc)

void	ExecResetTupleTable (List *tupleTable, bool shouldFree)

TupleTableSlot *	MakeSingleTupleTableSlot (TupleDesc tupdesc)

void	ExecDropSingleTupleTableSlot (TupleTableSlot *slot)

void	ExecSetSlotDescriptor (TupleTableSlot *slot, TupleDesc tupdesc)

TupleTableSlot *	ExecStoreTuple (HeapTuple tuple, TupleTableSlot *slot, Buffer buffer, bool shouldFree)

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

TupleTableSlot *	ExecClearTuple (TupleTableSlot *slot)

TupleTableSlot *	ExecStoreVirtualTuple (TupleTableSlot *slot)

TupleTableSlot *	ExecStoreAllNullTuple (TupleTableSlot *slot)

HeapTuple	ExecCopySlotTuple (TupleTableSlot *slot)

MinimalTuple	ExecCopySlotMinimalTuple (TupleTableSlot *slot)

HeapTuple	ExecFetchSlotTuple (TupleTableSlot *slot)

MinimalTuple	ExecFetchSlotMinimalTuple (TupleTableSlot *slot)

Datum	ExecFetchSlotTupleDatum (TupleTableSlot *slot)

HeapTuple	ExecMaterializeSlot (TupleTableSlot *slot)

TupleTableSlot *	ExecCopySlot (TupleTableSlot dstslot, TupleTableSlot srcslot)

void	ExecInitResultTupleSlotTL (EState estate, PlanState planstate)

void	ExecInitScanTupleSlot (EState estate, ScanState scanstate, TupleDesc tupledesc)

TupleTableSlot *	ExecInitExtraTupleSlot (EState *estate, TupleDesc tupledesc)

TupleTableSlot *	ExecInitNullTupleSlot (EState *estate, TupleDesc tupType)

TupleDesc	ExecTypeFromTL (List *targetList, bool hasoid)

TupleDesc	ExecCleanTypeFromTL (List *targetList, bool hasoid)

TupleDesc	ExecTypeFromExprList (List *exprList)

void	ExecTypeSetColNames (TupleDesc typeInfo, List *namesList)

TupleDesc	BlessTupleDesc (TupleDesc tupdesc)

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

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)

Function Documentation

◆ begin_tup_output_tupdesc()

TupOutputState* begin_tup_output_tupdesc	(	DestReceiver *	dest,
		TupleDesc	tupdesc
	)

Definition at line 1315 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);
     tstate->dest = dest;
 
     tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
 
     return tstate;
 }

◆ BlessTupleDesc()

TupleDesc BlessTupleDesc ( TupleDesc tupdesc )

Definition at line 1109 of file execTuples.c.

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

Referenced by aclexplode(), brin_metapage_info(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), exec_eval_datum(), ExecEvalWholeRowVar(), ExecInitExprRec(), ExecInitFunctionScan(), 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_prepared_xact(), pg_sequence_parameters(), pg_stat_file(), pg_stat_get_archiver(), 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(), TupleDescGetAttInMetadata(), and TupleDescGetSlot().

 {
     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 1195 of file execTuples.c.

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, heap_form_tuple(), i, InputFunctionCall(), tupleDesc::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(), materializeQueryResult(), 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 1361 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 1333 of file execTuples.c.

References TupOutputState::dest, ExecClearTuple(), ExecStoreVirtualTuple(), tupleDesc::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 1391 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
	)

Definition at line 167 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

Referenced by ExecInitExtraTupleSlot(), ExecInitResultTupleSlotTL(), ExecInitScanTupleSlot(), and find_hash_columns().

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

◆ ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL	(	List *	targetList,
		bool	hasoid
	)

Definition at line 977 of file execTuples.c.

References ExecTypeFromTLInternal().

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

 {
     return ExecTypeFromTLInternal(targetList, hasoid, true);
 }

◆ ExecClearTuple()

TupleTableSlot* ExecClearTuple ( TupleTableSlot * slot )

Definition at line 475 of file execTuples.c.

References Assert, BufferIsValid, heap_free_minimal_tuple(), heap_freetuple(), InvalidBuffer, ReleaseBuffer(), TupleTableSlot::tts_buffer, TupleTableSlot::tts_isempty, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_shouldFree, TupleTableSlot::tts_shouldFreeMin, and TupleTableSlot::tts_tuple.

Referenced by agg_retrieve_hash_table(), apply_handle_update(), apply_returning_filter(), begin_partition(), BitmapHeapNext(), buildSubPlanHash(), CteScanNext(), do_tup_output(), eval_windowaggregates(), ExecAppend(), ExecDelete(), ExecDropSingleTupleTableSlot(), ExecEndAgg(), ExecEndBitmapHeapScan(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHashJoin(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndMaterial(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNamedTuplestoreScan(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndValuesScan(), ExecEndWindowAgg(), ExecEndWorkTableScan(), ExecEvalAggOrderedTransTuple(), ExecFilterJunk(), ExecFindPartition(), ExecHashJoinGetSavedTuple(), ExecHashSubPlan(), ExecMaterial(), ExecMergeAppend(), ExecParallelHashJoinOuterGetTuple(), ExecProject(), ExecProjectSRF(), ExecReScanAgg(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanGroup(), ExecReScanMaterial(), ExecReScanMergeJoin(), ExecReScanNamedTuplestoreScan(), ExecReScanSetOp(), ExecReScanSort(), ExecReScanTableFuncScan(), ExecReScanUnique(), ExecReScanValuesScan(), ExecReScanWindowAgg(), ExecReScanWorkTableScan(), ExecResetTupleTable(), ExecScan(), ExecScanFetch(), ExecSetSlotDescriptor(), ExecStoreAllNullTuple(), ExecUnique(), ExecWindowAgg(), fetch_remote_table_info(), fetch_table_list(), fileIterateForeignScan(), FunctionNext(), gather_getnext(), gather_merge_clear_tuples(), gather_merge_init(), get_returning_data(), hypothetical_dense_rank_final(), hypothetical_rank_common(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), lookup_hash_entry(), ordered_set_shutdown(), ordered_set_transition_multi(), per_MultiFuncCall(), postgresIterateDirectModify(), postgresIterateForeignScan(), process_ordered_aggregate_multi(), RunFromStore(), SampleNext(), SeqNext(), setop_retrieve_direct(), setop_retrieve_hash_table(), ShutdownSetExpr(), slot_modify_cstrings(), slot_store_cstrings(), StoreIndexTuple(), tfuncLoadRows(), TidNext(), tuplesort_gettupleslot(), tuplestore_gettupleslot(), update_frameheadpos(), update_frametailpos(), update_grouptailpos(), ValuesNext(), and WinRowsArePeers().

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
 
     /*
      * Free the old physical tuple if necessary.
      */
     if (slot->tts_shouldFree)
         heap_freetuple(slot->tts_tuple);
     if (slot->tts_shouldFreeMin)
         heap_free_minimal_tuple(slot->tts_mintuple);
 
     slot->tts_tuple = NULL;
     slot->tts_mintuple = NULL;
     slot->tts_shouldFree = false;
     slot->tts_shouldFreeMin = false;
 
     /*
      * Drop the pin on the referenced buffer, if there is one.
      */
     if (BufferIsValid(slot->tts_buffer))
         ReleaseBuffer(slot->tts_buffer);
 
     slot->tts_buffer = InvalidBuffer;
 
     /*
      * Mark it empty.
      */
     slot->tts_isempty = true;
     slot->tts_nvalid = 0;
 
     return slot;
 }

◆ ExecCopySlot()

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

Definition at line 851 of file execTuples.c.

References ExecCopySlotTuple(), ExecStoreTuple(), InvalidBuffer, MemoryContextSwitchTo(), and TupleTableSlot::tts_mcxt.

Referenced by begin_partition(), CteScanNext(), ExecGroup(), ExecUnique(), ExecWindowAgg(), postgresRecheckForeignScan(), spool_tuples(), update_frameheadpos(), and update_frametailpos().

 {
     HeapTuple   newTuple;
     MemoryContext oldContext;
 
     /*
      * There might be ways to optimize this when the source is virtual, but
      * for now just always build a physical copy.  Make sure it is in the
      * right context.
      */
     oldContext = MemoryContextSwitchTo(dstslot->tts_mcxt);
     newTuple = ExecCopySlotTuple(srcslot);
     MemoryContextSwitchTo(oldContext);
 
     return ExecStoreTuple(newTuple, dstslot, InvalidBuffer, true);
 }

◆ ExecCopySlotMinimalTuple()

MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot * slot )

Definition at line 613 of file execTuples.c.

References Assert, heap_copy_minimal_tuple(), heap_form_minimal_tuple(), HeapTupleHeaderGetNatts, minimal_expand_tuple(), minimal_tuple_from_heap_tuple(), tupleDesc::natts, HeapTupleData::t_data, TupleTableSlot::tts_isempty, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_tuple, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

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

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!slot->tts_isempty);
 
     /*
      * If we have a physical tuple then just copy it.  Prefer to copy
      * tts_mintuple since that's a tad cheaper.
      */
     if (slot->tts_mintuple)
         return heap_copy_minimal_tuple(slot->tts_mintuple);
     if (slot->tts_tuple)
     {
         if (HeapTupleHeaderGetNatts(slot->tts_tuple->t_data)
             < slot->tts_tupleDescriptor->natts)
             return minimal_expand_tuple(slot->tts_tuple,
                                         slot->tts_tupleDescriptor);
         else
             return minimal_tuple_from_heap_tuple(slot->tts_tuple);
     }
 
     /*
      * Otherwise we need to build a tuple from the Datum array.
      */
     return heap_form_minimal_tuple(slot->tts_tupleDescriptor,
                                    slot->tts_values,
                                    slot->tts_isnull);
 }

◆ ExecCopySlotTuple()

HeapTuple ExecCopySlotTuple ( TupleTableSlot * slot )

Definition at line 581 of file execTuples.c.

References Assert, heap_copytuple(), heap_form_tuple(), heap_tuple_from_minimal_tuple(), TTS_HAS_PHYSICAL_TUPLE, TupleTableSlot::tts_isempty, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_tuple, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by agg_retrieve_direct(), ExecCopySlot(), ExecMaterializeSlot(), ExecScanSubPlan(), ExecSetParamPlan(), setop_retrieve_direct(), and spi_printtup().

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!slot->tts_isempty);
 
     /*
      * If we have a physical tuple (either format) then just copy it.
      */
     if (TTS_HAS_PHYSICAL_TUPLE(slot))
         return heap_copytuple(slot->tts_tuple);
     if (slot->tts_mintuple)
         return heap_tuple_from_minimal_tuple(slot->tts_mintuple);
 
     /*
      * Otherwise we need to build a tuple from the Datum array.
      */
     return heap_form_tuple(slot->tts_tupleDescriptor,
                            slot->tts_values,
                            slot->tts_isnull);
 }

◆ ExecDropSingleTupleTableSlot()

void ExecDropSingleTupleTableSlot ( TupleTableSlot * slot )

Definition at line 247 of file execTuples.c.

References Assert, ExecClearTuple(), IsA, pfree(), ReleaseTupleDesc, TupleTableSlot::tts_fixedTupleDescriptor, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), compute_index_stats(), end_tup_output(), ExecCleanupTupleRouting(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), hypothetical_dense_rank_final(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), ProjIndexIsUnchanged(), RunFromStore(), tuplesort_end(), unique_key_recheck(), validate_index_heapscan(), and validateCheckConstraint().

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

◆ ExecFetchSlotMinimalTuple()

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot * slot )

Definition at line 708 of file execTuples.c.

References Assert, ExecCopySlotMinimalTuple(), MemoryContextSwitchTo(), TupleTableSlot::tts_isempty, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_mintuple, and TupleTableSlot::tts_shouldFreeMin.

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

 {
     MemoryContext oldContext;
 
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!slot->tts_isempty);
 
     /*
      * If we have a minimal physical tuple (local or not) then just return it.
      */
     if (slot->tts_mintuple)
         return slot->tts_mintuple;
 
     /*
      * Otherwise, copy or build a minimal tuple, and store it into the slot.
      *
      * We may be called in a context that is shorter-lived than the tuple
      * slot, but we have to ensure that the materialized tuple will survive
      * anyway.
      */
     oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
     slot->tts_mintuple = ExecCopySlotMinimalTuple(slot);
     slot->tts_shouldFreeMin = true;
     MemoryContextSwitchTo(oldContext);
 
     /*
      * Note: we may now have a situation where we have a local minimal tuple
      * attached to a virtual or non-local physical tuple.  There seems no harm
      * in that at the moment, but if any materializes, we should change this
      * function to force the slot into minimal-tuple-only state.
      */
 
     return slot->tts_mintuple;
 }

◆ ExecFetchSlotTuple()

HeapTuple ExecFetchSlotTuple ( TupleTableSlot * slot )

Definition at line 661 of file execTuples.c.

References Assert, ExecMaterializeSlot(), ExecStoreTuple(), heap_expand_tuple(), HeapTupleHeaderGetNatts, InvalidBuffer, MemoryContextSwitchTo(), tupleDesc::natts, HeapTupleData::t_data, TTS_HAS_PHYSICAL_TUPLE, TupleTableSlot::tts_isempty, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_tuple, and TupleTableSlot::tts_tupleDescriptor.

Referenced by ExecConstraints(), ExecFetchSlotTupleDatum(), ExecFindPartition(), ExecPartitionCheckEmitError(), and ExecWithCheckOptions().

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!slot->tts_isempty);
 
     /*
      * If we have a regular physical tuple then just return it.
      */
     if (TTS_HAS_PHYSICAL_TUPLE(slot))
     {
         if (HeapTupleHeaderGetNatts(slot->tts_tuple->t_data) <
             slot->tts_tupleDescriptor->natts)
         {
             HeapTuple   tuple;
             MemoryContext oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
 
             tuple = heap_expand_tuple(slot->tts_tuple,
                                       slot->tts_tupleDescriptor);
             MemoryContextSwitchTo(oldContext);
             slot = ExecStoreTuple(tuple, slot, InvalidBuffer, true);
         }
         return slot->tts_tuple;
     }
 
     /*
      * Otherwise materialize the slot...
      */
     return ExecMaterializeSlot(slot);
 }

◆ ExecFetchSlotTupleDatum()

Datum ExecFetchSlotTupleDatum ( TupleTableSlot * slot )

Definition at line 754 of file execTuples.c.

References ExecFetchSlotTuple(), heap_copy_tuple_as_datum(), and TupleTableSlot::tts_tupleDescriptor.

Referenced by ExecMakeFunctionResultSet(), and postquel_get_single_result().

 {
     HeapTuple   tup;
     TupleDesc   tupdesc;
 
     /* Fetch slot's contents in regular-physical-tuple form */
     tup = ExecFetchSlotTuple(slot);
     tupdesc = slot->tts_tupleDescriptor;
 
     /* Convert to Datum form */
     return heap_copy_tuple_as_datum(tup, tupdesc);
 }

◆ ExecInitExtraTupleSlot()

TupleTableSlot* ExecInitExtraTupleSlot	(	EState *	estate,
		TupleDesc	tupledesc
	)

Definition at line 931 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(), CopyFrom(), create_estate_for_relation(), ExecInitAgg(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHashJoin(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNullTupleSlot(), ExecInitSubPlan(), ExecInitWholeRowVar(), ExecInitWindowAgg(), gather_merge_setup(), InitPlan(), and TriggerEnabled().

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

◆ ExecInitNullTupleSlot()

TupleTableSlot* ExecInitNullTupleSlot	(	EState *	estate,
		TupleDesc	tupType
	)

Definition at line 945 of file execTuples.c.

References ExecInitExtraTupleSlot(), and ExecStoreAllNullTuple().

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

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

◆ ExecInitResultTupleSlotTL()

void ExecInitResultTupleSlotTL	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 890 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), ExecContextForcesOids(), ExecTypeFromTL(), PlanState::plan, PlanState::ps_ResultTupleSlot, and Plan::targetlist.

Referenced by ExecInitAgg(), ExecInitAppend(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitValuesScan(), ExecInitWindowAgg(), and ExecInitWorkTableScan().

 {
     bool        hasoid;
     TupleDesc   tupDesc;
 
     if (ExecContextForcesOids(planstate, &hasoid))
     {
         /* context forces OID choice; hasoid is now set correctly */
     }
     else
     {
         /* given free choice, don't leave space for OIDs in result tuples */
         hasoid = false;
     }
 
     tupDesc = ExecTypeFromTL(planstate->plan->targetlist, hasoid);
 
     planstate->ps_ResultTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable, tupDesc);
 }

◆ ExecInitScanTupleSlot()

void ExecInitScanTupleSlot	(	EState *	estate,
		ScanState *	scanstate,
		TupleDesc	tupledesc
	)

Definition at line 915 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), ScanState::ps, PlanState::scandesc, 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);
     scanstate->ps.scandesc = tupledesc;
 }

◆ ExecMaterializeSlot()

HeapTuple ExecMaterializeSlot ( TupleTableSlot * slot )

Definition at line 781 of file execTuples.c.

References Assert, BufferIsValid, ExecCopySlotTuple(), InvalidBuffer, MemoryContextSwitchTo(), ReleaseBuffer(), TupleTableSlot::tts_buffer, TupleTableSlot::tts_isempty, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_shouldFree, TupleTableSlot::tts_shouldFreeMin, and TupleTableSlot::tts_tuple.

Referenced by AfterTriggerExecute(), apply_returning_filter(), CopyFrom(), EvalPlanQual(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecDelete(), ExecFetchSlotTuple(), ExecInsert(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecPrepareTupleRouting(), ExecProcessReturning(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), ExecUpdate(), ForeignNext(), intorel_receive(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), tqueueReceiveSlot(), and transientrel_receive().

 {
     MemoryContext oldContext;
 
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(!slot->tts_isempty);
 
     /*
      * If we have a regular physical tuple, and it's locally palloc'd, we have
      * nothing to do.
      */
     if (slot->tts_tuple && slot->tts_shouldFree)
         return slot->tts_tuple;
 
     /*
      * Otherwise, copy or build a physical tuple, and store it into the slot.
      *
      * We may be called in a context that is shorter-lived than the tuple
      * slot, but we have to ensure that the materialized tuple will survive
      * anyway.
      */
     oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
     slot->tts_tuple = ExecCopySlotTuple(slot);
     slot->tts_shouldFree = true;
     MemoryContextSwitchTo(oldContext);
 
     /*
      * Drop the pin on the referenced buffer, if there is one.
      */
     if (BufferIsValid(slot->tts_buffer))
         ReleaseBuffer(slot->tts_buffer);
 
     slot->tts_buffer = InvalidBuffer;
 
     /*
      * Mark extracted state invalid.  This is important because the slot is
      * not supposed to depend any more on the previous external data; we
      * mustn't leave any dangling pass-by-reference datums in tts_values.
      * However, we have not actually invalidated any such datums, if there
      * happen to be any previously fetched from the slot.  (Note in particular
      * that we have not pfree'd tts_mintuple, if there is one.)
      */
     slot->tts_nvalid = 0;
 
     /*
      * On the same principle of not depending on previous remote storage,
      * forget the mintuple if it's not local storage.  (If it is local
      * storage, we must not pfree it now, since callers might have already
      * fetched datum pointers referencing it.)
      */
     if (!slot->tts_shouldFreeMin)
         slot->tts_mintuple = NULL;
 
     return slot->tts_tuple;
 }

◆ ExecResetTupleTable()

void ExecResetTupleTable	(	List *	tupleTable,
		bool	shouldFree
	)

Definition at line 186 of file execTuples.c.

References ExecClearTuple(), lfirst_node, list_free(), pfree(), ReleaseTupleDesc, TupleTableSlot::tts_fixedTupleDescriptor, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

Referenced by 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);
         if (slot->tts_tupleDescriptor)
         {
             ReleaseTupleDesc(slot->tts_tupleDescriptor);
             slot->tts_tupleDescriptor = NULL;
         }
 
         /* If shouldFree, release memory occupied by the slot itself */
         if (shouldFree)
         {
             if (!slot->tts_fixedTupleDescriptor)
             {
                 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 281 of file execTuples.c.

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

Referenced by apply_returning_filter(), ConvertPartitionTupleSlot(), ExecAssignScanType(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecConstraints(), ExecDelete(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitPartitionInfo(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecPartitionCheckEmitError(), ExecPrepareTupleRouting(), ExecWithCheckOptions(), and TriggerEnabled().

 {
     Assert(!slot->tts_fixedTupleDescriptor);
 
     /* 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 548 of file execTuples.c.

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

Referenced by 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);
 }

◆ ExecStoreMinimalTuple()

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

Definition at line 420 of file execTuples.c.

References Assert, BufferIsValid, heap_free_minimal_tuple(), heap_freetuple(), InvalidBuffer, MINIMAL_TUPLE_OFFSET, ReleaseBuffer(), HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, TupleTableSlot::tts_buffer, TupleTableSlot::tts_isempty, TupleTableSlot::tts_minhdr, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_shouldFree, TupleTableSlot::tts_shouldFreeMin, TupleTableSlot::tts_tuple, and TupleTableSlot::tts_tupleDescriptor.

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

 {
     /*
      * sanity checks
      */
     Assert(mtup != NULL);
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
 
     /*
      * Free any old physical tuple belonging to the slot.
      */
     if (slot->tts_shouldFree)
         heap_freetuple(slot->tts_tuple);
     if (slot->tts_shouldFreeMin)
         heap_free_minimal_tuple(slot->tts_mintuple);
 
     /*
      * Drop the pin on the referenced buffer, if there is one.
      */
     if (BufferIsValid(slot->tts_buffer))
         ReleaseBuffer(slot->tts_buffer);
 
     slot->tts_buffer = InvalidBuffer;
 
     /*
      * Store the new tuple into the specified slot.
      */
     slot->tts_isempty = false;
     slot->tts_shouldFree = false;
     slot->tts_shouldFreeMin = shouldFree;
     slot->tts_tuple = &slot->tts_minhdr;
     slot->tts_mintuple = mtup;
 
     slot->tts_minhdr.t_len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
     slot->tts_minhdr.t_data = (HeapTupleHeader) ((char *) mtup - MINIMAL_TUPLE_OFFSET);
     /* no need to set t_self or t_tableOid since we won't allow access */
 
     /* Mark extracted state invalid */
     slot->tts_nvalid = 0;
 
     return slot;
 }

◆ ExecStoreTuple()

TupleTableSlot* ExecStoreTuple	(	HeapTuple	tuple,
		TupleTableSlot *	slot,
		Buffer	buffer,
		bool	shouldFree
	)

Definition at line 356 of file execTuples.c.

References Assert, buffer, BufferIsValid, heap_free_minimal_tuple(), heap_freetuple(), IncrBufferRefCount(), ReleaseBuffer(), TupleTableSlot::tts_buffer, TupleTableSlot::tts_isempty, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_shouldFree, TupleTableSlot::tts_shouldFreeMin, TupleTableSlot::tts_tuple, and TupleTableSlot::tts_tupleDescriptor.

Referenced by agg_retrieve_direct(), apply_handle_update(), ATRewriteTable(), BitmapHeapNext(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), comparetup_cluster(), compute_index_stats(), ConvertPartitionTupleSlot(), CopyFrom(), CopyFromInsertBatch(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecConstraints(), ExecCopySlot(), ExecDelete(), ExecFetchSlotTuple(), ExecFindPartition(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecOnConflictUpdate(), ExecPartitionCheckEmitError(), ExecScanFetch(), ExecuteCallStmt(), ExecWithCheckOptions(), gather_getnext(), gather_merge_readnext(), get_actual_variable_range(), get_returning_data(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), postgresIterateForeignScan(), ProjIndexIsUnchanged(), RelationFindReplTupleByIndex(), RelationFindReplTupleSeq(), SampleNext(), SeqNext(), setop_retrieve_direct(), store_returning_result(), TidNext(), TriggerEnabled(), unique_key_recheck(), validate_index_heapscan(), and validateCheckConstraint().

 {
     /*
      * sanity checks
      */
     Assert(tuple != NULL);
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
     /* passing shouldFree=true for a tuple on a disk page is not sane */
     Assert(BufferIsValid(buffer) ? (!shouldFree) : true);
 
     /*
      * Free any old physical tuple belonging to the slot.
      */
     if (slot->tts_shouldFree)
         heap_freetuple(slot->tts_tuple);
     if (slot->tts_shouldFreeMin)
         heap_free_minimal_tuple(slot->tts_mintuple);
 
     /*
      * Store the new tuple into the specified slot.
      */
     slot->tts_isempty = false;
     slot->tts_shouldFree = shouldFree;
     slot->tts_shouldFreeMin = false;
     slot->tts_tuple = tuple;
     slot->tts_mintuple = NULL;
 
     /* Mark extracted state invalid */
     slot->tts_nvalid = 0;
 
     /*
      * If tuple is on a disk page, keep the page pinned as long as we hold a
      * pointer into it.  We assume the caller already has such a pin.
      *
      * This is coded to optimize the case where the slot previously held a
      * tuple on the same disk page: in that case releasing and re-acquiring
      * the pin is a waste of cycles.  This is a common situation during
      * seqscans, so it's worth troubling over.
      */
     if (slot->tts_buffer != buffer)
     {
         if (BufferIsValid(slot->tts_buffer))
             ReleaseBuffer(slot->tts_buffer);
         slot->tts_buffer = buffer;
         if (BufferIsValid(buffer))
             IncrBufferRefCount(buffer);
     }
 
     return slot;
 }

◆ ExecStoreVirtualTuple()

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot * slot )

Definition at line 524 of file execTuples.c.

References Assert, tupleDesc::natts, TupleTableSlot::tts_isempty, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_tupleDescriptor.

Referenced by agg_retrieve_hash_table(), apply_returning_filter(), do_tup_output(), ExecEvalAggOrderedTransTuple(), ExecFilterJunk(), ExecProjectSRF(), ExecStoreAllNullTuple(), fileIterateForeignScan(), FunctionNext(), hypothetical_dense_rank_final(), hypothetical_rank_common(), lookup_hash_entry(), ordered_set_transition_multi(), slot_modify_cstrings(), slot_store_cstrings(), StoreIndexTuple(), and ValuesNext().

 {
     /*
      * sanity checks
      */
     Assert(slot != NULL);
     Assert(slot->tts_tupleDescriptor != NULL);
     Assert(slot->tts_isempty);
 
     slot->tts_isempty = false;
     slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
 
     return slot;
 }

◆ ExecTypeFromExprList()

TupleDesc ExecTypeFromExprList ( List * exprList )

Definition at line 1024 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), false);
 
     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,
		bool	hasoid
	)

Definition at line 965 of file execTuples.c.

References ExecTypeFromTLInternal().

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

 {
     return ExecTypeFromTLInternal(targetList, hasoid, false);
 }

◆ ExecTypeFromTLInternal()

static TupleDesc ExecTypeFromTLInternal	(	List *	targetList,
		bool	hasoid,
		bool	skipjunk
	)

static

Definition at line 983 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, hasoid);
 
     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 1063 of file execTuples.c.

References lfirst, NameStr, namestrcpy(), tupleDesc::natts, strVal, tupleDesc::tdtypeid, tupleDesc::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 1284 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 )

Definition at line 232 of file execTuples.c.

References MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), BuildTupleHashTable(), CatalogIndexInsert(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), compute_index_stats(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecPrepareTuplestoreResult(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), get_partition_dispatch_recurse(), hypothetical_dense_rank_final(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), ordered_set_startup(), ProjIndexIsUnchanged(), RunFromStore(), TupleDescGetSlot(), tuplesort_begin_cluster(), unique_key_recheck(), validate_index_heapscan(), and validateCheckConstraint().

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

◆ MakeTupleTableSlot()

TupleTableSlot* MakeTupleTableSlot ( TupleDesc tupleDesc )

Definition at line 113 of file execTuples.c.

Referenced by ExecAllocTableSlot(), ExecSetupPartitionTupleRouting(), and MakeSingleTupleTableSlot().

 {
     Size        sz;
     TupleTableSlot *slot;
 
     /*
      * When a fixed descriptor is specified, we can reduce overhead by
      * allocating the entire slot in one go.
      */
     if (tupleDesc)
         sz = MAXALIGN(sizeof(TupleTableSlot)) +
             MAXALIGN(tupleDesc->natts * sizeof(Datum)) +
             MAXALIGN(tupleDesc->natts * sizeof(bool));
     else
         sz = sizeof(TupleTableSlot);
 
     slot = palloc0(sz);
     slot->type = T_TupleTableSlot;
     slot->tts_isempty = true;
     slot->tts_shouldFree = false;
     slot->tts_shouldFreeMin = false;
     slot->tts_tuple = NULL;
     slot->tts_fixedTupleDescriptor = tupleDesc != NULL;
     slot->tts_tupleDescriptor = tupleDesc;
     slot->tts_mcxt = CurrentMemoryContext;
     slot->tts_buffer = InvalidBuffer;
     slot->tts_nvalid = 0;
     slot->tts_values = NULL;
     slot->tts_isnull = NULL;
     slot->tts_mintuple = NULL;
 
     if (tupleDesc != NULL)
     {
         slot->tts_values = (Datum *)
             (((char *) slot)
              + MAXALIGN(sizeof(TupleTableSlot)));
         slot->tts_isnull = (bool *)
             (((char *) slot)
              + MAXALIGN(sizeof(TupleTableSlot))
              + MAXALIGN(tupleDesc->natts * sizeof(Datum)));
 
         PinTupleDesc(tupleDesc);
     }
 
     return slot;
 }

◆ TupleDescGetAttInMetadata()

AttInMetadata* TupleDescGetAttInMetadata ( TupleDesc tupdesc )

Definition at line 1146 of file execTuples.c.

References AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, BlessTupleDesc(), fmgr_info(), getTypeInputInfo(), i, tupleDesc::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(), materializeQueryResult(), materializeResult(), pg_config(), pg_get_keywords(), pg_get_multixact_members(), pg_logdir_ls_internal(), 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().

 {
     int         natts = tupdesc->natts;
     int         i;
     Oid         atttypeid;
     Oid         attinfuncid;
     FmgrInfo   *attinfuncinfo;
     Oid        *attioparams;
     int32      *atttypmods;
     AttInMetadata *attinmeta;
 
     attinmeta = (AttInMetadata *) palloc(sizeof(AttInMetadata));
 
     /* "Bless" the tupledesc so that we can make rowtype datums with it */
     attinmeta->tupdesc = BlessTupleDesc(tupdesc);
 
     /*
      * Gather info needed later to call the "in" function for each attribute
      */
     attinfuncinfo = (FmgrInfo *) palloc0(natts * sizeof(FmgrInfo));
     attioparams = (Oid *) palloc0(natts * sizeof(Oid));
     atttypmods = (int32 *) palloc0(natts * sizeof(int32));
 
     for (i = 0; i < natts; i++)
     {
         Form_pg_attribute att = TupleDescAttr(tupdesc, i);
 
         /* Ignore dropped attributes */
         if (!att->attisdropped)
         {
             atttypeid = att->atttypid;
             getTypeInputInfo(atttypeid, &attinfuncid, &attioparams[i]);
             fmgr_info(attinfuncid, &attinfuncinfo[i]);
             atttypmods[i] = att->atttypmod;
         }
     }
     attinmeta->attinfuncs = attinfuncinfo;
     attinmeta->attioparams = attioparams;
     attinmeta->atttypmods = atttypmods;
 
     return attinmeta;
 }

◆ TupleDescGetSlot()

TupleTableSlot* TupleDescGetSlot ( TupleDesc tupdesc )

Definition at line 1126 of file execTuples.c.

References BlessTupleDesc(), and MakeSingleTupleTableSlot().

 {
     TupleTableSlot *slot;
 
     /* The useful work is here */
     BlessTupleDesc(tupdesc);
 
     /* Make a standalone slot */
     slot = MakeSingleTupleTableSlot(tupdesc);
 
     /* Return the slot */
     return slot;
 }

Functions