#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 (void)

TupleTableSlot *	ExecAllocTableSlot (List **tupleTable)

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	ExecInitResultTupleSlot (EState estate, PlanState planstate)

void	ExecInitScanTupleSlot (EState estate, ScanState scanstate)

TupleTableSlot *	ExecInitExtraTupleSlot (EState *estate)

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

TupOutputState* begin_tup_output_tupdesc	(	DestReceiver *	dest,
		TupleDesc	tupdesc
	)

Definition at line 1235 of file execTuples.c.

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

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

TupleDesc BlessTupleDesc ( TupleDesc tupdesc )

Definition at line 1032 of file execTuples.c.

References assign_record_type_typmod(), RECORDOID, 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(), plpgsql_exec_get_datum_type(), plpgsql_exec_get_datum_type_info(), PLy_output_record_funcs(), populate_recordset_worker(), setup_firstcall(), ssl_extension_info(), 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 */
 }

HeapTuple BuildTupleFromCStrings	(	AttInMetadata *	attinmeta,
		char **	values
	)

Definition at line 1118 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(), 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 */
     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;
 }

void do_text_output_multiline	(	TupOutputState *	tstate,
		const char *	txt
	)

Definition at line 1281 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;
     }
 }

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

Definition at line 1253 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);
 }

void end_tup_output ( TupOutputState * tstate )

Definition at line 1311 of file execTuples.c.

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

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

TupleTableSlot* ExecAllocTableSlot ( List ** tupleTable )

Definition at line 137 of file execTuples.c.

References lappend(), and MakeTupleTableSlot().

Referenced by ExecInitExtraTupleSlot(), ExecInitResultTupleSlot(), and ExecInitScanTupleSlot().

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

TupleDesc ExecCleanTypeFromTL	(	List *	targetList,
		bool	hasoid
	)

Definition at line 900 of file execTuples.c.

References ExecTypeFromTLInternal().

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

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

TupleTableSlot* ExecClearTuple ( TupleTableSlot * slot )

Definition at line 439 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 advance_aggregates(), agg_retrieve_hash_table(), apply_handle_update(), 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(), ExecFilterJunk(), ExecGather(), ExecHashJoinGetSavedTuple(), ExecHashSubPlan(), ExecMaterial(), ExecMergeAppend(), ExecProject(), ExecProjectSRF(), ExecReScanAgg(), ExecReScanCteScan(), ExecReScanFunctionScan(), ExecReScanGroup(), ExecReScanMaterial(), ExecReScanMergeJoin(), ExecReScanNamedTuplestoreScan(), ExecReScanSetOp(), ExecReScanSort(), ExecReScanTableFuncScan(), ExecReScanUnique(), ExecReScanValuesScan(), ExecReScanWindowAgg(), ExecReScanWorkTableScan(), ExecResetTupleTable(), ExecScan(), ExecScanFetch(), ExecSetSlotDescriptor(), ExecStoreAllNullTuple(), ExecUnique(), fetch_remote_table_info(), fetch_table_list(), fileIterateForeignScan(), FunctionNext(), gather_getnext(), gather_merge_clear_tuples(), gather_merge_init(), get_partition_for_tuple(), 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(), 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;
 }

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

Definition at line 795 of file execTuples.c.

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

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

 {
     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);
 }

MinimalTuple ExecCopySlotMinimalTuple ( TupleTableSlot * slot )

Definition at line 577 of file execTuples.c.

References Assert, heap_copy_minimal_tuple(), heap_form_minimal_tuple(), minimal_tuple_from_heap_tuple(), 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)
         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);
 }

HeapTuple ExecCopySlotTuple ( TupleTableSlot * slot )

Definition at line 545 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);
 }

void ExecDropSingleTupleTableSlot ( TupleTableSlot * slot )

Definition at line 216 of file execTuples.c.

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

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), CatalogIndexInsert(), check_default_allows_bound(), check_exclusion_or_unique_constraint(), compute_index_stats(), CopyFrom(), end_tup_output(), ExecEndModifyTable(), fetch_remote_table_info(), fetch_table_list(), get_actual_variable_range(), hypothetical_dense_rank_final(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), 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_values)
         pfree(slot->tts_values);
     if (slot->tts_isnull)
         pfree(slot->tts_isnull);
     pfree(slot);
 }

MinimalTuple ExecFetchSlotMinimalTuple ( TupleTableSlot * slot )

Definition at line 652 of file execTuples.c.

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

Referenced by ExecHashJoin(), ExecHashSkewTableInsert(), and ExecHashTableInsert().

 {
     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;
 }

HeapTuple ExecFetchSlotTuple ( TupleTableSlot * slot )

Definition at line 618 of file execTuples.c.

References Assert, ExecMaterializeSlot(), TTS_HAS_PHYSICAL_TUPLE, TupleTableSlot::tts_isempty, and TupleTableSlot::tts_tuple.

Referenced by ExecConstraints(), ExecFetchSlotTupleDatum(), ExecPartitionCheck(), ExecWithCheckOptions(), and get_partition_for_tuple().

 {
     /*
      * 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))
         return slot->tts_tuple;
 
     /*
      * Otherwise materialize the slot...
      */
     return ExecMaterializeSlot(slot);
 }

Datum ExecFetchSlotTupleDatum ( TupleTableSlot * slot )

Definition at line 698 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);
 }

TupleTableSlot* ExecInitExtraTupleSlot ( EState * estate )

Definition at line 852 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);
 }

TupleTableSlot* ExecInitNullTupleSlot	(	EState *	estate,
		TupleDesc	tupType
	)

Definition at line 866 of file execTuples.c.

References ExecInitExtraTupleSlot(), ExecSetSlotDescriptor(), and ExecStoreAllNullTuple().

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

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

void ExecInitResultTupleSlot	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 832 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), and PlanState::ps_ResultTupleSlot.

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

 {
     planstate->ps_ResultTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable);
 }

void ExecInitScanTupleSlot	(	EState *	estate,
		ScanState *	scanstate
	)

Definition at line 842 of file execTuples.c.

References EState::es_tupleTable, ExecAllocTableSlot(), and ScanState::ss_ScanTupleSlot.

Referenced by ExecInitAgg(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGroup(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitMaterial(), ExecInitNamedTuplestoreScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitValuesScan(), ExecInitWindowAgg(), and ExecInitWorkTableScan().

 {
     scanstate->ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable);
 }

HeapTuple ExecMaterializeSlot ( TupleTableSlot * slot )

Definition at line 725 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(), CopyFrom(), EvalPlanQual(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecDelete(), ExecFetchSlotTuple(), ExecInsert(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), 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;
 }

void ExecResetTupleTable	(	List *	tupleTable,
		bool	shouldFree
	)

Definition at line 156 of file execTuples.c.

References ExecClearTuple(), lfirst_node, list_free(), pfree(), ReleaseTupleDesc, 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_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);
 }

void ExecSetSlotDescriptor	(	TupleTableSlot *	slot,
		TupleDesc	tupdesc
	)

Definition at line 247 of file execTuples.c.

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

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_update(), build_pertrans_for_aggref(), CopyFrom(), ExecAssignResultType(), ExecAssignScanType(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecConstraints(), ExecDelete(), ExecInitAgg(), ExecInitFunctionScan(), ExecInitGather(), ExecInitHashJoin(), ExecInitJunkFilter(), ExecInitJunkFilterConversion(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNullTupleSlot(), ExecInitSubPlan(), ExecInitWindowAgg(), ExecInsert(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecPartitionCheck(), ExecWithCheckOptions(), find_hash_columns(), gather_merge_setup(), MakeSingleTupleTableSlot(), and TriggerEnabled().

 {
     /* 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));
 }

TupleTableSlot* ExecStoreAllNullTuple ( TupleTableSlot * slot )

Definition at line 512 of file execTuples.c.

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

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

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

Definition at line 384 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(), 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;
 }

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

Definition at line 320 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_allows_bound(), check_exclusion_or_unique_constraint(), comparetup_cluster(), compute_index_stats(), CopyFrom(), CopyFromInsertBatch(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecConstraints(), ExecCopySlot(), ExecDelete(), ExecInsert(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecOnConflictUpdate(), ExecPartitionCheck(), ExecScanFetch(), ExecWithCheckOptions(), gather_getnext(), gather_merge_readnext(), get_actual_variable_range(), get_partition_for_tuple(), get_returning_data(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), postgresIterateForeignScan(), 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;
 }

TupleTableSlot* ExecStoreVirtualTuple ( TupleTableSlot * slot )

Definition at line 488 of file execTuples.c.

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

Referenced by advance_aggregates(), agg_retrieve_hash_table(), do_tup_output(), 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;
 }

TupleDesc ExecTypeFromExprList ( List * exprList )

Definition at line 947 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;
 }

TupleDesc ExecTypeFromTL	(	List *	targetList,
		bool	hasoid
	)

Definition at line 888 of file execTuples.c.

References ExecTypeFromTLInternal().

Referenced by build_pertrans_for_aggref(), ExecAssignResultTypeFromTL(), ExecInitAgg(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitIndexOnlyScan(), ExecInitModifyTable(), ExecInitSubPlan(), find_hash_columns(), and ordered_set_startup().

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

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

static

Definition at line 906 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;
 }

void ExecTypeSetColNames	(	TupleDesc	typeInfo,
		List *	namesList
	)

Definition at line 986 of file execTuples.c.

References lfirst, NameStr, namestrcpy(), tupleDesc::natts, RECORDOID, 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;
     }
 }

Datum HeapTupleHeaderGetDatum ( HeapTupleHeader tuple )

Definition at line 1204 of file execTuples.c.

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

Referenced by populate_composite().

 {
     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;
 }

TupleTableSlot* MakeSingleTupleTableSlot ( TupleDesc tupdesc )

Definition at line 199 of file execTuples.c.

References ExecSetSlotDescriptor(), and MakeTupleTableSlot().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), begin_tup_output_tupdesc(), CatalogIndexInsert(), check_default_allows_bound(), 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(), LookupTupleHashEntry(), ordered_set_startup(), RunFromStore(), TupleDescGetSlot(), tuplesort_begin_cluster(), unique_key_recheck(), validate_index_heapscan(), and validateCheckConstraint().

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

TupleTableSlot* MakeTupleTableSlot ( void )

Definition at line 111 of file execTuples.c.

References CurrentMemoryContext, InvalidBuffer, makeNode, TupleTableSlot::tts_buffer, TupleTableSlot::tts_isempty, TupleTableSlot::tts_isnull, TupleTableSlot::tts_mcxt, TupleTableSlot::tts_mintuple, TupleTableSlot::tts_nvalid, TupleTableSlot::tts_shouldFree, TupleTableSlot::tts_shouldFreeMin, TupleTableSlot::tts_tuple, TupleTableSlot::tts_tupleDescriptor, and TupleTableSlot::tts_values.

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

 {
     TupleTableSlot *slot = makeNode(TupleTableSlot);
 
     slot->tts_isempty = true;
     slot->tts_shouldFree = false;
     slot->tts_shouldFreeMin = false;
     slot->tts_tuple = NULL;
     slot->tts_tupleDescriptor = NULL;
     slot->tts_mcxt = CurrentMemoryContext;
     slot->tts_buffer = InvalidBuffer;
     slot->tts_nvalid = 0;
     slot->tts_values = NULL;
     slot->tts_isnull = NULL;
     slot->tts_mintuple = NULL;
 
     return slot;
 }

AttInMetadata* TupleDescGetAttInMetadata ( TupleDesc tupdesc )

Definition at line 1069 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(), 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(), pgp_armor_headers(), pgrowlocks(), pgstatindex_impl(), pltcl_build_tuple_result(), pltcl_func_handler(), pltcl_init_tuple_store(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignModify(), 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;
 }

TupleTableSlot* TupleDescGetSlot ( TupleDesc tupdesc )

Definition at line 1049 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

Function Documentation