#include "executor/execdesc.h"
#include "fmgr.h"
#include "nodes/lockoptions.h"
#include "nodes/parsenodes.h"
#include "utils/memutils.h"

Include dependency graph for executor.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	TupOutputState

Macros
#define	EXEC_FLAG_EXPLAIN_ONLY 0x0001 /* EXPLAIN, no ANALYZE */

#define	EXEC_FLAG_EXPLAIN_GENERIC 0x0002 /* EXPLAIN (GENERIC_PLAN) */

#define	EXEC_FLAG_REWIND 0x0004 /* need efficient rescan */

#define	EXEC_FLAG_BACKWARD 0x0008 /* need backward scan */

#define	EXEC_FLAG_MARK 0x0010 /* need mark/restore */

#define	EXEC_FLAG_SKIP_TRIGGERS 0x0020 /* skip AfterTrigger setup */

#define	EXEC_FLAG_WITH_NO_DATA 0x0040 /* REFRESH ... WITH NO DATA */

#define	EvalPlanQualSetSlot(epqstate, slot) ((epqstate)->origslot = (slot))

#define	do_text_output_oneline(tstate, str_to_emit)

#define	ResetExprContext(econtext) MemoryContextReset((econtext)->ecxt_per_tuple_memory)

#define	GetPerTupleExprContext(estate)

#define	GetPerTupleMemoryContext(estate) (GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)

#define	ResetPerTupleExprContext(estate)

Typedefs
typedef void(*	ExecutorStart_hook_type) (QueryDesc *queryDesc, int eflags)

typedef void(*	ExecutorRun_hook_type) (QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)

typedef void(*	ExecutorFinish_hook_type) (QueryDesc *queryDesc)

typedef void(*	ExecutorEnd_hook_type) (QueryDesc *queryDesc)

typedef bool(*	ExecutorCheckPerms_hook_type) (List rangeTable, List rtePermInfos, bool ereport_on_violation)

typedef TupleTableSlot (	ExecScanAccessMtd) (ScanState *node)

typedef bool(*	ExecScanRecheckMtd) (ScanState node, TupleTableSlot slot)

typedef struct TupOutputState	TupOutputState

Functions
void	ExecReScan (PlanState *node)

void	ExecMarkPos (PlanState *node)

void	ExecRestrPos (PlanState *node)

bool	ExecSupportsMarkRestore (struct Path *pathnode)

bool	ExecSupportsBackwardScan (Plan *node)

bool	ExecMaterializesOutput (NodeTag plantype)

bool	execCurrentOf (CurrentOfExpr cexpr, ExprContext econtext, Oid table_oid, ItemPointer current_tid)

ExprState *	execTuplesMatchPrepare (TupleDesc desc, int numCols, const AttrNumber keyColIdx, const Oid eqOperators, const Oid collations, PlanState parent)

void	execTuplesHashPrepare (int numCols, const Oid eqOperators, Oid eqFuncOids, FmgrInfo *hashFunctions)

TupleHashTable	BuildTupleHashTable (PlanState parent, TupleDesc inputDesc, int numCols, AttrNumber keyColIdx, const Oid eqfuncoids, FmgrInfo hashfunctions, Oid *collations, long nbuckets, Size additionalsize, MemoryContext tablecxt, MemoryContext tempcxt, bool use_variable_hash_iv)

TupleHashTable	BuildTupleHashTableExt (PlanState parent, TupleDesc inputDesc, int numCols, AttrNumber keyColIdx, const Oid eqfuncoids, FmgrInfo hashfunctions, Oid *collations, long nbuckets, Size additionalsize, MemoryContext metacxt, MemoryContext tablecxt, MemoryContext tempcxt, bool use_variable_hash_iv)

TupleHashEntry	LookupTupleHashEntry (TupleHashTable hashtable, TupleTableSlot slot, bool isnew, uint32 *hash)

uint32	TupleHashTableHash (TupleHashTable hashtable, TupleTableSlot *slot)

TupleHashEntry	LookupTupleHashEntryHash (TupleHashTable hashtable, TupleTableSlot slot, bool isnew, uint32 hash)

TupleHashEntry	FindTupleHashEntry (TupleHashTable hashtable, TupleTableSlot slot, ExprState eqcomp, FmgrInfo *hashfunctions)

void	ResetTupleHashTable (TupleHashTable hashtable)

JunkFilter *	ExecInitJunkFilter (List targetList, TupleTableSlot slot)

JunkFilter *	ExecInitJunkFilterConversion (List targetList, TupleDesc cleanTupType, TupleTableSlot slot)

AttrNumber	ExecFindJunkAttribute (JunkFilter junkfilter, const char attrName)

AttrNumber	ExecFindJunkAttributeInTlist (List targetlist, const char attrName)

TupleTableSlot *	ExecFilterJunk (JunkFilter junkfilter, TupleTableSlot slot)

static Datum	ExecGetJunkAttribute (TupleTableSlot slot, AttrNumber attno, bool isNull)

void	ExecutorStart (QueryDesc *queryDesc, int eflags)

void	standard_ExecutorStart (QueryDesc *queryDesc, int eflags)

void	ExecutorRun (QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)

void	standard_ExecutorRun (QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)

void	ExecutorFinish (QueryDesc *queryDesc)

void	standard_ExecutorFinish (QueryDesc *queryDesc)

void	ExecutorEnd (QueryDesc *queryDesc)

void	standard_ExecutorEnd (QueryDesc *queryDesc)

void	ExecutorRewind (QueryDesc *queryDesc)

bool	ExecCheckPermissions (List rangeTable, List rteperminfos, bool ereport_on_violation)

void	CheckValidResultRel (ResultRelInfo *resultRelInfo, CmdType operation)

void	InitResultRelInfo (ResultRelInfo resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo partition_root_rri, int instrument_options)

ResultRelInfo *	ExecGetTriggerResultRel (EState estate, Oid relid, ResultRelInfo rootRelInfo)

List *	ExecGetAncestorResultRels (EState estate, ResultRelInfo resultRelInfo)

void	ExecConstraints (ResultRelInfo resultRelInfo, TupleTableSlot slot, EState *estate)

bool	ExecPartitionCheck (ResultRelInfo resultRelInfo, TupleTableSlot slot, EState *estate, bool emitError)

void	ExecPartitionCheckEmitError (ResultRelInfo resultRelInfo, TupleTableSlot slot, EState *estate)

void	ExecWithCheckOptions (WCOKind kind, ResultRelInfo resultRelInfo, TupleTableSlot slot, EState *estate)

LockTupleMode	ExecUpdateLockMode (EState estate, ResultRelInfo relinfo)

ExecRowMark *	ExecFindRowMark (EState *estate, Index rti, bool missing_ok)

ExecAuxRowMark *	ExecBuildAuxRowMark (ExecRowMark erm, List targetlist)

TupleTableSlot *	EvalPlanQual (EPQState epqstate, Relation relation, Index rti, TupleTableSlot inputslot)

void	EvalPlanQualInit (EPQState epqstate, EState parentestate, Plan subplan, List auxrowmarks, int epqParam, List *resultRelations)

void	EvalPlanQualSetPlan (EPQState epqstate, Plan subplan, List *auxrowmarks)

TupleTableSlot *	EvalPlanQualSlot (EPQState *epqstate, Relation relation, Index rti)

bool	EvalPlanQualFetchRowMark (EPQState epqstate, Index rti, TupleTableSlot slot)

TupleTableSlot *	EvalPlanQualNext (EPQState *epqstate)

void	EvalPlanQualBegin (EPQState *epqstate)

void	EvalPlanQualEnd (EPQState *epqstate)

PlanState *	ExecInitNode (Plan node, EState estate, int eflags)

void	ExecSetExecProcNode (PlanState *node, ExecProcNodeMtd function)

Node *	MultiExecProcNode (PlanState *node)

void	ExecEndNode (PlanState *node)

void	ExecShutdownNode (PlanState *node)

void	ExecSetTupleBound (int64 tuples_needed, PlanState *child_node)

static TupleTableSlot *	ExecProcNode (PlanState *node)

ExprState *	ExecInitExpr (Expr node, PlanState parent)

ExprState *	ExecInitExprWithParams (Expr *node, ParamListInfo ext_params)

ExprState *	ExecInitQual (List qual, PlanState parent)

ExprState *	ExecInitCheck (List qual, PlanState parent)

List *	ExecInitExprList (List nodes, PlanState parent)

ExprState *	ExecBuildAggTrans (AggState aggstate, struct AggStatePerPhaseData phase, bool doSort, bool doHash, bool nullcheck)

ExprState *	ExecBuildGroupingEqual (TupleDesc ldesc, TupleDesc rdesc, const TupleTableSlotOps lops, const TupleTableSlotOps rops, int numCols, const AttrNumber keyColIdx, const Oid eqfunctions, const Oid collations, PlanState parent)

ExprState *	ExecBuildParamSetEqual (TupleDesc desc, const TupleTableSlotOps lops, const TupleTableSlotOps rops, const Oid eqfunctions, const Oid collations, const List param_exprs, PlanState parent)

ProjectionInfo *	ExecBuildProjectionInfo (List targetList, ExprContext econtext, TupleTableSlot slot, PlanState parent, TupleDesc inputDesc)

ProjectionInfo *	ExecBuildUpdateProjection (List targetList, bool evalTargetList, List targetColnos, TupleDesc relDesc, ExprContext econtext, TupleTableSlot slot, PlanState *parent)

ExprState *	ExecPrepareExpr (Expr node, EState estate)

ExprState *	ExecPrepareQual (List qual, EState estate)

ExprState *	ExecPrepareCheck (List qual, EState estate)

List *	ExecPrepareExprList (List nodes, EState estate)

static Datum	ExecEvalExpr (ExprState state, ExprContext econtext, bool *isNull)

static Datum	ExecEvalExprSwitchContext (ExprState state, ExprContext econtext, bool *isNull)

static TupleTableSlot *	ExecProject (ProjectionInfo *projInfo)

static bool	ExecQual (ExprState state, ExprContext econtext)

static bool	ExecQualAndReset (ExprState state, ExprContext econtext)

bool	ExecCheck (ExprState state, ExprContext econtext)

SetExprState *	ExecInitTableFunctionResult (Expr expr, ExprContext econtext, PlanState *parent)

Tuplestorestate *	ExecMakeTableFunctionResult (SetExprState setexpr, ExprContext econtext, MemoryContext argContext, TupleDesc expectedDesc, bool randomAccess)

SetExprState *	ExecInitFunctionResultSet (Expr expr, ExprContext econtext, PlanState *parent)

Datum	ExecMakeFunctionResultSet (SetExprState fcache, ExprContext econtext, MemoryContext argContext, bool isNull, ExprDoneCond isDone)

TupleTableSlot *	ExecScan (ScanState *node, ExecScanAccessMtd accessMtd, ExecScanRecheckMtd recheckMtd)

void	ExecAssignScanProjectionInfo (ScanState *node)

void	ExecAssignScanProjectionInfoWithVarno (ScanState *node, int varno)

void	ExecScanReScan (ScanState *node)

void	ExecInitResultTypeTL (PlanState *planstate)

void	ExecInitResultSlot (PlanState planstate, const TupleTableSlotOps tts_ops)

void	ExecInitResultTupleSlotTL (PlanState planstate, const TupleTableSlotOps tts_ops)

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

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

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

TupleDesc	ExecTypeFromTL (List *targetList)

TupleDesc	ExecCleanTypeFromTL (List *targetList)

TupleDesc	ExecTypeFromExprList (List *exprList)

void	ExecTypeSetColNames (TupleDesc typeInfo, List *namesList)

void	UpdateChangedParamSet (PlanState node, Bitmapset newchg)

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

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

void	do_text_output_multiline (TupOutputState tstate, const char txt)

void	end_tup_output (TupOutputState *tstate)

EState *	CreateExecutorState (void)

void	FreeExecutorState (EState *estate)

ExprContext *	CreateExprContext (EState *estate)

ExprContext *	CreateWorkExprContext (EState *estate)

ExprContext *	CreateStandaloneExprContext (void)

void	FreeExprContext (ExprContext *econtext, bool isCommit)

void	ReScanExprContext (ExprContext *econtext)

ExprContext *	MakePerTupleExprContext (EState *estate)

void	ExecAssignExprContext (EState estate, PlanState planstate)

TupleDesc	ExecGetResultType (PlanState *planstate)

const TupleTableSlotOps *	ExecGetResultSlotOps (PlanState planstate, bool isfixed)

void	ExecAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc)

void	ExecConditionalAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc, int varno)

void	ExecAssignScanType (ScanState *scanstate, TupleDesc tupDesc)

void	ExecCreateScanSlotFromOuterPlan (EState estate, ScanState scanstate, const TupleTableSlotOps *tts_ops)

bool	ExecRelationIsTargetRelation (EState *estate, Index scanrelid)

Relation	ExecOpenScanRelation (EState *estate, Index scanrelid, int eflags)

void	ExecInitRangeTable (EState estate, List rangeTable, List *permInfos)

void	ExecCloseRangeTableRelations (EState *estate)

void	ExecCloseResultRelations (EState *estate)

static RangeTblEntry *	exec_rt_fetch (Index rti, EState *estate)

Relation	ExecGetRangeTableRelation (EState *estate, Index rti)

void	ExecInitResultRelation (EState estate, ResultRelInfo resultRelInfo, Index rti)

int	executor_errposition (EState *estate, int location)

void	RegisterExprContextCallback (ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)

void	UnregisterExprContextCallback (ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)

Datum	GetAttributeByName (HeapTupleHeader tuple, const char attname, bool isNull)

Datum	GetAttributeByNum (HeapTupleHeader tuple, AttrNumber attrno, bool *isNull)

int	ExecTargetListLength (List *targetlist)

int	ExecCleanTargetListLength (List *targetlist)

TupleTableSlot *	ExecGetTriggerOldSlot (EState estate, ResultRelInfo relInfo)

TupleTableSlot *	ExecGetTriggerNewSlot (EState estate, ResultRelInfo relInfo)

TupleTableSlot *	ExecGetReturningSlot (EState estate, ResultRelInfo relInfo)

TupleConversionMap *	ExecGetChildToRootMap (ResultRelInfo *resultRelInfo)

TupleConversionMap *	ExecGetRootToChildMap (ResultRelInfo resultRelInfo, EState estate)

Oid	ExecGetResultRelCheckAsUser (ResultRelInfo relInfo, EState estate)

Bitmapset *	ExecGetInsertedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetUpdatedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetExtraUpdatedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetAllUpdatedCols (ResultRelInfo relinfo, EState estate)

void	ExecOpenIndices (ResultRelInfo *resultRelInfo, bool speculative)

void	ExecCloseIndices (ResultRelInfo *resultRelInfo)

List *	ExecInsertIndexTuples (ResultRelInfo resultRelInfo, TupleTableSlot slot, EState estate, bool update, bool noDupErr, bool specConflict, List *arbiterIndexes, bool onlySummarizing)

bool	ExecCheckIndexConstraints (ResultRelInfo resultRelInfo, TupleTableSlot slot, EState estate, ItemPointer conflictTid, List arbiterIndexes)

void	check_exclusion_constraint (Relation heap, Relation index, IndexInfo indexInfo, ItemPointer tupleid, const Datum values, const bool isnull, EState estate, bool newIndex)

StrategyNumber	get_equal_strategy_number_for_am (Oid am)

bool	RelationFindReplTupleByIndex (Relation rel, Oid idxoid, LockTupleMode lockmode, TupleTableSlot searchslot, TupleTableSlot outslot)

bool	RelationFindReplTupleSeq (Relation rel, LockTupleMode lockmode, TupleTableSlot searchslot, TupleTableSlot outslot)

void	ExecSimpleRelationInsert (ResultRelInfo resultRelInfo, EState estate, TupleTableSlot *slot)

void	ExecSimpleRelationUpdate (ResultRelInfo resultRelInfo, EState estate, EPQState epqstate, TupleTableSlot searchslot, TupleTableSlot *slot)

void	ExecSimpleRelationDelete (ResultRelInfo resultRelInfo, EState estate, EPQState epqstate, TupleTableSlot searchslot)

void	CheckCmdReplicaIdentity (Relation rel, CmdType cmd)

void	CheckSubscriptionRelkind (char relkind, const char nspname, const char relname)

TupleTableSlot *	ExecGetUpdateNewTuple (ResultRelInfo relinfo, TupleTableSlot planSlot, TupleTableSlot *oldSlot)

ResultRelInfo *	ExecLookupResultRelByOid (ModifyTableState *node, Oid resultoid, bool missing_ok, bool update_cache)

Variables
PGDLLIMPORT ExecutorStart_hook_type	ExecutorStart_hook

PGDLLIMPORT ExecutorRun_hook_type	ExecutorRun_hook

PGDLLIMPORT ExecutorFinish_hook_type	ExecutorFinish_hook

PGDLLIMPORT ExecutorEnd_hook_type	ExecutorEnd_hook

PGDLLIMPORT ExecutorCheckPerms_hook_type	ExecutorCheckPerms_hook

Macro Definition Documentation

◆ do_text_output_oneline

#define do_text_output_oneline	(	tstate,
		str_to_emit
	)

Value:

    do { \
        Datum   values_[1]; \
        bool    isnull_[1]; \
        values_[0] = PointerGetDatum(cstring_to_text(str_to_emit)); \
        isnull_[0] = false; \
        do_tup_output(tstate, values_, isnull_); \
        pfree(DatumGetPointer(values_[0])); \
    } while (0)

Definition at line 521 of file executor.h.

◆ EvalPlanQualSetSlot

#define EvalPlanQualSetSlot	(	epqstate,
		slot
	)	((epqstate)->origslot = (slot))

Definition at line 243 of file executor.h.

◆ EXEC_FLAG_BACKWARD

#define EXEC_FLAG_BACKWARD 0x0008 /* need backward scan */

Definition at line 68 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_GENERIC

#define EXEC_FLAG_EXPLAIN_GENERIC 0x0002 /* EXPLAIN (GENERIC_PLAN) */

Definition at line 66 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_ONLY

#define EXEC_FLAG_EXPLAIN_ONLY 0x0001 /* EXPLAIN, no ANALYZE */

Definition at line 65 of file executor.h.

◆ EXEC_FLAG_MARK

#define EXEC_FLAG_MARK 0x0010 /* need mark/restore */

Definition at line 69 of file executor.h.

◆ EXEC_FLAG_REWIND

#define EXEC_FLAG_REWIND 0x0004 /* need efficient rescan */

Definition at line 67 of file executor.h.

◆ EXEC_FLAG_SKIP_TRIGGERS

#define EXEC_FLAG_SKIP_TRIGGERS 0x0020 /* skip AfterTrigger setup */

Definition at line 70 of file executor.h.

◆ EXEC_FLAG_WITH_NO_DATA

#define EXEC_FLAG_WITH_NO_DATA 0x0040 /* REFRESH ... WITH NO DATA */

Definition at line 71 of file executor.h.

◆ GetPerTupleExprContext

#define GetPerTupleExprContext ( estate )

Value:

    ((estate)->es_per_tuple_exprcontext ? \
     (estate)->es_per_tuple_exprcontext : \
     MakePerTupleExprContext(estate))

Definition at line 549 of file executor.h.

◆ GetPerTupleMemoryContext

#define GetPerTupleMemoryContext ( estate ) (GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)

Definition at line 554 of file executor.h.

◆ ResetExprContext

#define ResetExprContext ( econtext ) MemoryContextReset((econtext)->ecxt_per_tuple_memory)

Definition at line 543 of file executor.h.

◆ ResetPerTupleExprContext

#define ResetPerTupleExprContext ( estate )

Value:

    do { \
        if ((estate)->es_per_tuple_exprcontext) \
            ResetExprContext((estate)->es_per_tuple_exprcontext); \
    } while (0)

Definition at line 558 of file executor.h.

Typedef Documentation

◆ ExecScanAccessMtd

typedef TupleTableSlot*(* ExecScanAccessMtd) (ScanState *node)

Definition at line 472 of file executor.h.

◆ ExecScanRecheckMtd

typedef bool(* ExecScanRecheckMtd) (ScanState *node, TupleTableSlot *slot)

Definition at line 473 of file executor.h.

◆ ExecutorCheckPerms_hook_type

typedef bool(* ExecutorCheckPerms_hook_type) (List *rangeTable, List *rtePermInfos, bool ereport_on_violation)

Definition at line 94 of file executor.h.

◆ ExecutorEnd_hook_type

typedef void(* ExecutorEnd_hook_type) (QueryDesc *queryDesc)

Definition at line 90 of file executor.h.

◆ ExecutorFinish_hook_type

typedef void(* ExecutorFinish_hook_type) (QueryDesc *queryDesc)

Definition at line 86 of file executor.h.

◆ ExecutorRun_hook_type

typedef void(* ExecutorRun_hook_type) (QueryDesc *queryDesc, ScanDirection direction, uint64 count, bool execute_once)

Definition at line 79 of file executor.h.

◆ ExecutorStart_hook_type

typedef void(* ExecutorStart_hook_type) (QueryDesc *queryDesc, int eflags)

Definition at line 75 of file executor.h.

◆ TupOutputState

typedef struct TupOutputState TupOutputState

Function Documentation

◆ begin_tup_output_tupdesc()

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

Definition at line 2254 of file execTuples.c.

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

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

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

◆ BuildTupleHashTable()

TupleHashTable BuildTupleHashTable	(	PlanState *	parent,
		TupleDesc	inputDesc,
		int	numCols,
		AttrNumber *	keyColIdx,
		const Oid *	eqfuncoids,
		FmgrInfo *	hashfunctions,
		Oid *	collations,
		long	nbuckets,
		Size	additionalsize,
		MemoryContext	tablecxt,
		MemoryContext	tempcxt,
		bool	use_variable_hash_iv
	)

Definition at line 255 of file execGrouping.c.

 {
     return BuildTupleHashTableExt(parent,
                                   inputDesc,
                                   numCols, keyColIdx,
                                   eqfuncoids,
                                   hashfunctions,
                                   collations,
                                   nbuckets, additionalsize,
                                   tablecxt,
                                   tablecxt,
                                   tempcxt,
                                   use_variable_hash_iv);
 }

References BuildTupleHashTableExt().

◆ BuildTupleHashTableExt()

TupleHashTable BuildTupleHashTableExt	(	PlanState *	parent,
		TupleDesc	inputDesc,
		int	numCols,
		AttrNumber *	keyColIdx,
		const Oid *	eqfuncoids,
		FmgrInfo *	hashfunctions,
		Oid *	collations,
		long	nbuckets,
		Size	additionalsize,
		MemoryContext	metacxt,
		MemoryContext	tablecxt,
		MemoryContext	tempcxt,
		bool	use_variable_hash_iv
	)

Definition at line 154 of file execGrouping.c.

 {
     TupleHashTable hashtable;
     Size        entrysize = sizeof(TupleHashEntryData) + additionalsize;
     Size        hash_mem_limit;
     MemoryContext oldcontext;
     bool        allow_jit;
  
     Assert(nbuckets > 0);
  
     /* Limit initial table size request to not more than hash_mem */
     hash_mem_limit = get_hash_memory_limit() / entrysize;
     if (nbuckets > hash_mem_limit)
         nbuckets = hash_mem_limit;
  
     oldcontext = MemoryContextSwitchTo(metacxt);
  
     hashtable = (TupleHashTable) palloc(sizeof(TupleHashTableData));
  
     hashtable->numCols = numCols;
     hashtable->keyColIdx = keyColIdx;
     hashtable->tab_hash_funcs = hashfunctions;
     hashtable->tab_collations = collations;
     hashtable->tablecxt = tablecxt;
     hashtable->tempcxt = tempcxt;
     hashtable->entrysize = entrysize;
     hashtable->tableslot = NULL;    /* will be made on first lookup */
     hashtable->inputslot = NULL;
     hashtable->in_hash_funcs = NULL;
     hashtable->cur_eq_func = NULL;
  
     /*
      * If parallelism is in use, even if the leader backend is performing the
      * scan itself, we don't want to create the hashtable exactly the same way
      * in all workers. As hashtables are iterated over in keyspace-order,
      * doing so in all processes in the same way is likely to lead to
      * "unbalanced" hashtables when the table size initially is
      * underestimated.
      */
     if (use_variable_hash_iv)
         hashtable->hash_iv = murmurhash32(ParallelWorkerNumber);
     else
         hashtable->hash_iv = 0;
  
     hashtable->hashtab = tuplehash_create(metacxt, nbuckets, hashtable);
  
     /*
      * We copy the input tuple descriptor just for safety --- we assume all
      * input tuples will have equivalent descriptors.
      */
     hashtable->tableslot = MakeSingleTupleTableSlot(CreateTupleDescCopy(inputDesc),
                                                     &TTSOpsMinimalTuple);
  
     /*
      * If the old reset interface is used (i.e. BuildTupleHashTable, rather
      * than BuildTupleHashTableExt), allowing JIT would lead to the generated
      * functions to a) live longer than the query b) be re-generated each time
      * the table is being reset. Therefore prevent JIT from being used in that
      * case, by not providing a parent node (which prevents accessing the
      * JitContext in the EState).
      */
     allow_jit = metacxt != tablecxt;
  
     /* build comparator for all columns */
     /* XXX: should we support non-minimal tuples for the inputslot? */
     hashtable->tab_eq_func = ExecBuildGroupingEqual(inputDesc, inputDesc,
                                                     &TTSOpsMinimalTuple, &TTSOpsMinimalTuple,
                                                     numCols,
                                                     keyColIdx, eqfuncoids, collations,
                                                     allow_jit ? parent : NULL);
  
     /*
      * While not pretty, it's ok to not shut down this context, but instead
      * rely on the containing memory context being reset, as
      * ExecBuildGroupingEqual() only builds a very simple expression calling
      * functions (i.e. nothing that'd employ RegisterExprContextCallback()).
      */
     hashtable->exprcontext = CreateStandaloneExprContext();
  
     MemoryContextSwitchTo(oldcontext);
  
     return hashtable;
 }

Referenced by build_hash_table(), buildSubPlanHash(), and BuildTupleHashTable().

◆ check_exclusion_constraint()

void check_exclusion_constraint	(	Relation	heap,
		Relation	index,
		IndexInfo *	indexInfo,
		ItemPointer	tupleid,
		const Datum *	values,
		const bool *	isnull,
		EState *	estate,
		bool	newIndex
	)

Definition at line 915 of file execIndexing.c.

 {
     (void) check_exclusion_or_unique_constraint(heap, index, indexInfo, tupleid,
                                                 values, isnull,
                                                 estate, newIndex,
                                                 CEOUC_WAIT, false, NULL);
 }

References CEOUC_WAIT, check_exclusion_or_unique_constraint(), and values.

Referenced by IndexCheckExclusion().

◆ CheckCmdReplicaIdentity()

void CheckCmdReplicaIdentity	(	Relation	rel,
		CmdType	cmd
	)

Definition at line 658 of file execReplication.c.

 {
     PublicationDesc pubdesc;
  
     /*
      * Skip checking the replica identity for partitioned tables, because the
      * operations are actually performed on the leaf partitions.
      */
     if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         return;
  
     /* We only need to do checks for UPDATE and DELETE. */
     if (cmd != CMD_UPDATE && cmd != CMD_DELETE)
         return;
  
     /*
      * It is only safe to execute UPDATE/DELETE when all columns, referenced
      * in the row filters from publications which the relation is in, are
      * valid - i.e. when all referenced columns are part of REPLICA IDENTITY
      * or the table does not publish UPDATEs or DELETEs.
      *
      * XXX We could optimize it by first checking whether any of the
      * publications have a row filter for this relation. If not and relation
      * has replica identity then we can avoid building the descriptor but as
      * this happens only one time it doesn't seem worth the additional
      * complexity.
      */
     RelationBuildPublicationDesc(rel, &pubdesc);
     if (cmd == CMD_UPDATE && !pubdesc.rf_valid_for_update)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("cannot update table \"%s\"",
                         RelationGetRelationName(rel)),
                  errdetail("Column used in the publication WHERE expression is not part of the replica identity.")));
     else if (cmd == CMD_UPDATE && !pubdesc.cols_valid_for_update)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("cannot update table \"%s\"",
                         RelationGetRelationName(rel)),
                  errdetail("Column list used by the publication does not cover the replica identity.")));
     else if (cmd == CMD_DELETE && !pubdesc.rf_valid_for_delete)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("cannot delete from table \"%s\"",
                         RelationGetRelationName(rel)),
                  errdetail("Column used in the publication WHERE expression is not part of the replica identity.")));
     else if (cmd == CMD_DELETE && !pubdesc.cols_valid_for_delete)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                  errmsg("cannot delete from table \"%s\"",
                         RelationGetRelationName(rel)),
                  errdetail("Column list used by the publication does not cover the replica identity.")));
  
     /* If relation has replica identity we are always good. */
     if (OidIsValid(RelationGetReplicaIndex(rel)))
         return;
  
     /* REPLICA IDENTITY FULL is also good for UPDATE/DELETE. */
     if (rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
         return;
  
     /*
      * This is UPDATE/DELETE and there is no replica identity.
      *
      * Check if the table publishes UPDATES or DELETES.
      */
     if (cmd == CMD_UPDATE && pubdesc.pubactions.pubupdate)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("cannot update table \"%s\" because it does not have a replica identity and publishes updates",
                         RelationGetRelationName(rel)),
                  errhint("To enable updating the table, set REPLICA IDENTITY using ALTER TABLE.")));
     else if (cmd == CMD_DELETE && pubdesc.pubactions.pubdelete)
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("cannot delete from table \"%s\" because it does not have a replica identity and publishes deletes",
                         RelationGetRelationName(rel)),
                  errhint("To enable deleting from the table, set REPLICA IDENTITY using ALTER TABLE.")));
 }

References CMD_DELETE, CMD_UPDATE, PublicationDesc::cols_valid_for_delete, PublicationDesc::cols_valid_for_update, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, OidIsValid, PublicationDesc::pubactions, PublicationActions::pubdelete, PublicationActions::pubupdate, RelationData::rd_rel, RelationBuildPublicationDesc(), RelationGetRelationName, RelationGetReplicaIndex(), PublicationDesc::rf_valid_for_delete, and PublicationDesc::rf_valid_for_update.

Referenced by CheckValidResultRel(), ExecSimpleRelationDelete(), ExecSimpleRelationInsert(), and ExecSimpleRelationUpdate().

◆ CheckSubscriptionRelkind()

void CheckSubscriptionRelkind	(	char	relkind,
		const char *	nspname,
		const char *	relname
	)

Definition at line 745 of file execReplication.c.

 {
     if (relkind != RELKIND_RELATION && relkind != RELKIND_PARTITIONED_TABLE)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("cannot use relation \"%s.%s\" as logical replication target",
                         nspname, relname),
                  errdetail_relkind_not_supported(relkind)));
 }

References ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, and relname.

Referenced by AlterSubscription_refresh(), apply_handle_tuple_routing(), CreateSubscription(), and logicalrep_rel_open().

◆ CheckValidResultRel()

void CheckValidResultRel	(	ResultRelInfo *	resultRelInfo,
		CmdType	operation
	)

Definition at line 1024 of file execMain.c.

 {
     Relation    resultRel = resultRelInfo->ri_RelationDesc;
     TriggerDesc *trigDesc = resultRel->trigdesc;
     FdwRoutine *fdwroutine;
  
     switch (resultRel->rd_rel->relkind)
     {
         case RELKIND_RELATION:
         case RELKIND_PARTITIONED_TABLE:
             CheckCmdReplicaIdentity(resultRel, operation);
             break;
         case RELKIND_SEQUENCE:
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot change sequence \"%s\"",
                             RelationGetRelationName(resultRel))));
             break;
         case RELKIND_TOASTVALUE:
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot change TOAST relation \"%s\"",
                             RelationGetRelationName(resultRel))));
             break;
         case RELKIND_VIEW:
  
             /*
              * Okay only if there's a suitable INSTEAD OF trigger.  Messages
              * here should match rewriteHandler.c's rewriteTargetView and
              * RewriteQuery, except that we omit errdetail because we haven't
              * got the information handy (and given that we really shouldn't
              * get here anyway, it's not worth great exertion to get).
              */
             switch (operation)
             {
                 case CMD_INSERT:
                     if (!trigDesc || !trigDesc->trig_insert_instead_row)
                         ereport(ERROR,
                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                  errmsg("cannot insert into view \"%s\"",
                                         RelationGetRelationName(resultRel)),
                                  errhint("To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule.")));
                     break;
                 case CMD_UPDATE:
                     if (!trigDesc || !trigDesc->trig_update_instead_row)
                         ereport(ERROR,
                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                  errmsg("cannot update view \"%s\"",
                                         RelationGetRelationName(resultRel)),
                                  errhint("To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule.")));
                     break;
                 case CMD_DELETE:
                     if (!trigDesc || !trigDesc->trig_delete_instead_row)
                         ereport(ERROR,
                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                  errmsg("cannot delete from view \"%s\"",
                                         RelationGetRelationName(resultRel)),
                                  errhint("To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule.")));
                     break;
                 default:
                     elog(ERROR, "unrecognized CmdType: %d", (int) operation);
                     break;
             }
             break;
         case RELKIND_MATVIEW:
             if (!MatViewIncrementalMaintenanceIsEnabled())
                 ereport(ERROR,
                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                          errmsg("cannot change materialized view \"%s\"",
                                 RelationGetRelationName(resultRel))));
             break;
         case RELKIND_FOREIGN_TABLE:
             /* Okay only if the FDW supports it */
             fdwroutine = resultRelInfo->ri_FdwRoutine;
             switch (operation)
             {
                 case CMD_INSERT:
                     if (fdwroutine->ExecForeignInsert == NULL)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot insert into foreign table \"%s\"",
                                         RelationGetRelationName(resultRel))));
                     if (fdwroutine->IsForeignRelUpdatable != NULL &&
                         (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
                         ereport(ERROR,
                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                  errmsg("foreign table \"%s\" does not allow inserts",
                                         RelationGetRelationName(resultRel))));
                     break;
                 case CMD_UPDATE:
                     if (fdwroutine->ExecForeignUpdate == NULL)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot update foreign table \"%s\"",
                                         RelationGetRelationName(resultRel))));
                     if (fdwroutine->IsForeignRelUpdatable != NULL &&
                         (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_UPDATE)) == 0)
                         ereport(ERROR,
                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                  errmsg("foreign table \"%s\" does not allow updates",
                                         RelationGetRelationName(resultRel))));
                     break;
                 case CMD_DELETE:
                     if (fdwroutine->ExecForeignDelete == NULL)
                         ereport(ERROR,
                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                  errmsg("cannot delete from foreign table \"%s\"",
                                         RelationGetRelationName(resultRel))));
                     if (fdwroutine->IsForeignRelUpdatable != NULL &&
                         (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_DELETE)) == 0)
                         ereport(ERROR,
                                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                  errmsg("foreign table \"%s\" does not allow deletes",
                                         RelationGetRelationName(resultRel))));
                     break;
                 default:
                     elog(ERROR, "unrecognized CmdType: %d", (int) operation);
                     break;
             }
             break;
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("cannot change relation \"%s\"",
                             RelationGetRelationName(resultRel))));
             break;
     }
 }

References CheckCmdReplicaIdentity(), CMD_DELETE, CMD_INSERT, CMD_UPDATE, elog(), ereport, errcode(), errhint(), errmsg(), ERROR, FdwRoutine::ExecForeignDelete, FdwRoutine::ExecForeignInsert, FdwRoutine::ExecForeignUpdate, FdwRoutine::IsForeignRelUpdatable, MatViewIncrementalMaintenanceIsEnabled(), RelationData::rd_rel, RelationGetRelationName, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_RelationDesc, TriggerDesc::trig_delete_instead_row, TriggerDesc::trig_insert_instead_row, TriggerDesc::trig_update_instead_row, and RelationData::trigdesc.

Referenced by CopyFrom(), ExecFindPartition(), ExecInitModifyTable(), and ExecInitPartitionInfo().

◆ CreateExecutorState()

EState* CreateExecutorState ( void )

Definition at line 93 of file execUtils.c.

 {
     EState     *estate;
     MemoryContext qcontext;
     MemoryContext oldcontext;
  
     /*
      * Create the per-query context for this Executor run.
      */
     qcontext = AllocSetContextCreate(CurrentMemoryContext,
                                      "ExecutorState",
                                      ALLOCSET_DEFAULT_SIZES);
  
     /*
      * Make the EState node within the per-query context.  This way, we don't
      * need a separate pfree() operation for it at shutdown.
      */
     oldcontext = MemoryContextSwitchTo(qcontext);
  
     estate = makeNode(EState);
  
     /*
      * Initialize all fields of the Executor State structure
      */
     estate->es_direction = ForwardScanDirection;
     estate->es_snapshot = InvalidSnapshot;  /* caller must initialize this */
     estate->es_crosscheck_snapshot = InvalidSnapshot;   /* no crosscheck */
     estate->es_range_table = NIL;
     estate->es_range_table_size = 0;
     estate->es_relations = NULL;
     estate->es_rowmarks = NULL;
     estate->es_rteperminfos = NIL;
     estate->es_plannedstmt = NULL;
  
     estate->es_junkFilter = NULL;
  
     estate->es_output_cid = (CommandId) 0;
  
     estate->es_result_relations = NULL;
     estate->es_opened_result_relations = NIL;
     estate->es_tuple_routing_result_relations = NIL;
     estate->es_trig_target_relations = NIL;
  
     estate->es_insert_pending_result_relations = NIL;
     estate->es_insert_pending_modifytables = NIL;
  
     estate->es_param_list_info = NULL;
     estate->es_param_exec_vals = NULL;
  
     estate->es_queryEnv = NULL;
  
     estate->es_query_cxt = qcontext;
  
     estate->es_tupleTable = NIL;
  
     estate->es_processed = 0;
     estate->es_total_processed = 0;
  
     estate->es_top_eflags = 0;
     estate->es_instrument = 0;
     estate->es_finished = false;
  
     estate->es_exprcontexts = NIL;
  
     estate->es_subplanstates = NIL;
  
     estate->es_auxmodifytables = NIL;
  
     estate->es_per_tuple_exprcontext = NULL;
  
     estate->es_sourceText = NULL;
  
     estate->es_use_parallel_mode = false;
  
     estate->es_jit_flags = 0;
     estate->es_jit = NULL;
  
     /*
      * Return the executor state structure
      */
     MemoryContextSwitchTo(oldcontext);
  
     return estate;
 }

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, EState::es_auxmodifytables, EState::es_crosscheck_snapshot, EState::es_direction, EState::es_exprcontexts, EState::es_finished, EState::es_insert_pending_modifytables, EState::es_insert_pending_result_relations, EState::es_instrument, EState::es_jit, EState::es_jit_flags, EState::es_junkFilter, EState::es_opened_result_relations, EState::es_output_cid, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_per_tuple_exprcontext, EState::es_plannedstmt, EState::es_processed, EState::es_query_cxt, EState::es_queryEnv, EState::es_range_table, EState::es_range_table_size, EState::es_relations, EState::es_result_relations, EState::es_rowmarks, EState::es_rteperminfos, EState::es_snapshot, EState::es_sourceText, EState::es_subplanstates, EState::es_top_eflags, EState::es_total_processed, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, EState::es_tupleTable, EState::es_use_parallel_mode, ForwardScanDirection, InvalidSnapshot, makeNode, MemoryContextSwitchTo(), and NIL.

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), compute_index_stats(), CopyFrom(), create_edata_for_relation(), create_estate_for_relation(), EvalPlanQualStart(), evaluate_expr(), ExecuteCallStmt(), ExecuteQuery(), ExecuteTruncateGuts(), ExplainExecuteQuery(), fileIterateForeignScan(), get_qual_for_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), make_build_data(), operator_predicate_proof(), plpgsql_create_econtext(), plpgsql_inline_handler(), standard_ExecutorStart(), StoreAttrDefault(), tuplesort_begin_cluster(), and validateDomainConstraint().

◆ CreateExprContext()

ExprContext* CreateExprContext ( EState * estate )

Definition at line 309 of file execUtils.c.

 {
     return CreateExprContextInternal(estate, ALLOCSET_DEFAULT_SIZES);
 }

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

Referenced by ExecAssignExprContext(), ExecInitMergeJoin(), ExecInitSubPlan(), ExecuteCallStmt(), MakePerTupleExprContext(), and plpgsql_create_econtext().

◆ CreateStandaloneExprContext()

ExprContext* CreateStandaloneExprContext ( void )

Definition at line 360 of file execUtils.c.

 {
     ExprContext *econtext;
  
     /* Create the ExprContext node within the caller's memory context */
     econtext = makeNode(ExprContext);
  
     /* Initialize fields of ExprContext */
     econtext->ecxt_scantuple = NULL;
     econtext->ecxt_innertuple = NULL;
     econtext->ecxt_outertuple = NULL;
  
     econtext->ecxt_per_query_memory = CurrentMemoryContext;
  
     /*
      * Create working memory for expression evaluation in this context.
      */
     econtext->ecxt_per_tuple_memory =
         AllocSetContextCreate(CurrentMemoryContext,
                               "ExprContext",
                               ALLOCSET_DEFAULT_SIZES);
  
     econtext->ecxt_param_exec_vals = NULL;
     econtext->ecxt_param_list_info = NULL;
  
     econtext->ecxt_aggvalues = NULL;
     econtext->ecxt_aggnulls = NULL;
  
     econtext->caseValue_datum = (Datum) 0;
     econtext->caseValue_isNull = true;
  
     econtext->domainValue_datum = (Datum) 0;
     econtext->domainValue_isNull = true;
  
     econtext->ecxt_estate = NULL;
  
     econtext->ecxt_callbacks = NULL;
  
     return econtext;
 }

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ExprContext::caseValue_datum, ExprContext::caseValue_isNull, CurrentMemoryContext, ExprContext::domainValue_datum, ExprContext::domainValue_isNull, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExprContext::ecxt_callbacks, ExprContext::ecxt_estate, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_param_exec_vals, ExprContext::ecxt_param_list_info, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_per_tuple_memory, ExprContext::ecxt_scantuple, and makeNode.

Referenced by BuildTupleHashTableExt(), domain_check_input(), and hypothetical_dense_rank_final().

◆ CreateWorkExprContext()

ExprContext* CreateWorkExprContext ( EState * estate )

Definition at line 324 of file execUtils.c.

 {
     Size        minContextSize = ALLOCSET_DEFAULT_MINSIZE;
     Size        initBlockSize = ALLOCSET_DEFAULT_INITSIZE;
     Size        maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
  
     /* choose the maxBlockSize to be no larger than 1/16 of work_mem */
     while (16 * maxBlockSize > work_mem * 1024L)
         maxBlockSize >>= 1;
  
     if (maxBlockSize < ALLOCSET_DEFAULT_INITSIZE)
         maxBlockSize = ALLOCSET_DEFAULT_INITSIZE;
  
     return CreateExprContextInternal(estate, minContextSize,
                                      initBlockSize, maxBlockSize);
 }

References ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE, ALLOCSET_DEFAULT_MINSIZE, CreateExprContextInternal(), and work_mem.

Referenced by ExecInitAgg().

◆ do_text_output_multiline()

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

Definition at line 2302 of file execTuples.c.

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

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

Referenced by ExplainQuery().

◆ do_tup_output()

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

Definition at line 2274 of file execTuples.c.

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

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

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

◆ end_tup_output()

void end_tup_output ( TupOutputState * tstate )

Definition at line 2332 of file execTuples.c.

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

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

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

◆ EvalPlanQual()

TupleTableSlot* EvalPlanQual	(	EPQState *	epqstate,
		Relation	relation,
		Index	rti,
		TupleTableSlot *	inputslot
	)

Definition at line 2494 of file execMain.c.

 {
     TupleTableSlot *slot;
     TupleTableSlot *testslot;
  
     Assert(rti > 0);
  
     /*
      * Need to run a recheck subquery.  Initialize or reinitialize EPQ state.
      */
     EvalPlanQualBegin(epqstate);
  
     /*
      * Callers will often use the EvalPlanQualSlot to store the tuple to avoid
      * an unnecessary copy.
      */
     testslot = EvalPlanQualSlot(epqstate, relation, rti);
     if (testslot != inputslot)
         ExecCopySlot(testslot, inputslot);
  
     /*
      * Mark that an EPQ tuple is available for this relation.  (If there is
      * more than one result relation, the others remain marked as having no
      * tuple available.)
      */
     epqstate->relsubs_done[rti - 1] = false;
     epqstate->relsubs_blocked[rti - 1] = false;
  
     /*
      * Run the EPQ query.  We assume it will return at most one tuple.
      */
     slot = EvalPlanQualNext(epqstate);
  
     /*
      * If we got a tuple, force the slot to materialize the tuple so that it
      * is not dependent on any local state in the EPQ query (in particular,
      * it's highly likely that the slot contains references to any pass-by-ref
      * datums that may be present in copyTuple).  As with the next step, this
      * is to guard against early re-use of the EPQ query.
      */
     if (!TupIsNull(slot))
         ExecMaterializeSlot(slot);
  
     /*
      * Clear out the test tuple, and mark that no tuple is available here.
      * This is needed in case the EPQ state is re-used to test a tuple for a
      * different target relation.
      */
     ExecClearTuple(testslot);
     epqstate->relsubs_blocked[rti - 1] = true;
  
     return slot;
 }

References Assert(), EvalPlanQualBegin(), EvalPlanQualNext(), EvalPlanQualSlot(), ExecClearTuple(), ExecCopySlot(), ExecMaterializeSlot(), EPQState::relsubs_blocked, EPQState::relsubs_done, and TupIsNull.

Referenced by ExecDelete(), ExecMergeMatched(), ExecUpdate(), and GetTupleForTrigger().

◆ EvalPlanQualBegin()

void EvalPlanQualBegin ( EPQState * epqstate )

Definition at line 2775 of file execMain.c.

 {
     EState     *parentestate = epqstate->parentestate;
     EState     *recheckestate = epqstate->recheckestate;
  
     if (recheckestate == NULL)
     {
         /* First time through, so create a child EState */
         EvalPlanQualStart(epqstate, epqstate->plan);
     }
     else
     {
         /*
          * We already have a suitable child EPQ tree, so just reset it.
          */
         Index       rtsize = parentestate->es_range_table_size;
         PlanState  *rcplanstate = epqstate->recheckplanstate;
  
         /*
          * Reset the relsubs_done[] flags to equal relsubs_blocked[], so that
          * the EPQ run will never attempt to fetch tuples from blocked target
          * relations.
          */
         memcpy(epqstate->relsubs_done, epqstate->relsubs_blocked,
                rtsize * sizeof(bool));
  
         /* Recopy current values of parent parameters */
         if (parentestate->es_plannedstmt->paramExecTypes != NIL)
         {
             int         i;
  
             /*
              * Force evaluation of any InitPlan outputs that could be needed
              * by the subplan, just in case they got reset since
              * EvalPlanQualStart (see comments therein).
              */
             ExecSetParamPlanMulti(rcplanstate->plan->extParam,
                                   GetPerTupleExprContext(parentestate));
  
             i = list_length(parentestate->es_plannedstmt->paramExecTypes);
  
             while (--i >= 0)
             {
                 /* copy value if any, but not execPlan link */
                 recheckestate->es_param_exec_vals[i].value =
                     parentestate->es_param_exec_vals[i].value;
                 recheckestate->es_param_exec_vals[i].isnull =
                     parentestate->es_param_exec_vals[i].isnull;
             }
         }
  
         /*
          * Mark child plan tree as needing rescan at all scan nodes.  The
          * first ExecProcNode will take care of actually doing the rescan.
          */
         rcplanstate->chgParam = bms_add_member(rcplanstate->chgParam,
                                                epqstate->epqParam);
     }
 }

References bms_add_member(), PlanState::chgParam, EPQState::epqParam, EState::es_param_exec_vals, EState::es_plannedstmt, EState::es_range_table_size, EvalPlanQualStart(), ExecSetParamPlanMulti(), Plan::extParam, GetPerTupleExprContext, i, ParamExecData::isnull, list_length(), NIL, PlannedStmt::paramExecTypes, EPQState::parentestate, PlanState::plan, EPQState::plan, EPQState::recheckestate, EPQState::recheckplanstate, EPQState::relsubs_blocked, EPQState::relsubs_done, and ParamExecData::value.

Referenced by EvalPlanQual(), ExecDelete(), and ExecLockRows().

◆ EvalPlanQualEnd()

void EvalPlanQualEnd ( EPQState * epqstate )

Definition at line 3006 of file execMain.c.

 {
     EState     *estate = epqstate->recheckestate;
     Index       rtsize;
     MemoryContext oldcontext;
     ListCell   *l;
  
     rtsize = epqstate->parentestate->es_range_table_size;
  
     /*
      * We may have a tuple table, even if EPQ wasn't started, because we allow
      * use of EvalPlanQualSlot() without calling EvalPlanQualBegin().
      */
     if (epqstate->tuple_table != NIL)
     {
         memset(epqstate->relsubs_slot, 0,
                rtsize * sizeof(TupleTableSlot *));
         ExecResetTupleTable(epqstate->tuple_table, true);
         epqstate->tuple_table = NIL;
     }
  
     /* EPQ wasn't started, nothing further to do */
     if (estate == NULL)
         return;
  
     oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
  
     ExecEndNode(epqstate->recheckplanstate);
  
     foreach(l, estate->es_subplanstates)
     {
         PlanState  *subplanstate = (PlanState *) lfirst(l);
  
         ExecEndNode(subplanstate);
     }
  
     /* throw away the per-estate tuple table, some node may have used it */
     ExecResetTupleTable(estate->es_tupleTable, false);
  
     /* Close any result and trigger target relations attached to this EState */
     ExecCloseResultRelations(estate);
  
     MemoryContextSwitchTo(oldcontext);
  
     FreeExecutorState(estate);
  
     /* Mark EPQState idle */
     epqstate->origslot = NULL;
     epqstate->recheckestate = NULL;
     epqstate->recheckplanstate = NULL;
     epqstate->relsubs_rowmark = NULL;
     epqstate->relsubs_done = NULL;
     epqstate->relsubs_blocked = NULL;
 }

References EState::es_query_cxt, EState::es_range_table_size, EState::es_subplanstates, EState::es_tupleTable, ExecCloseResultRelations(), ExecEndNode(), ExecResetTupleTable(), FreeExecutorState(), lfirst, MemoryContextSwitchTo(), NIL, EPQState::origslot, EPQState::parentestate, EPQState::recheckestate, EPQState::recheckplanstate, EPQState::relsubs_blocked, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, and EPQState::tuple_table.

Referenced by apply_handle_delete_internal(), apply_handle_tuple_routing(), apply_handle_update_internal(), EvalPlanQualSetPlan(), ExecEndLockRows(), ExecEndModifyTable(), and ExecLockRows().

◆ EvalPlanQualFetchRowMark()

bool EvalPlanQualFetchRowMark	(	EPQState *	epqstate,
		Index	rti,
		TupleTableSlot *	slot
	)

Definition at line 2650 of file execMain.c.

 {
     ExecAuxRowMark *earm = epqstate->relsubs_rowmark[rti - 1];
     ExecRowMark *erm = earm->rowmark;
     Datum       datum;
     bool        isNull;
  
     Assert(earm != NULL);
     Assert(epqstate->origslot != NULL);
  
     if (RowMarkRequiresRowShareLock(erm->markType))
         elog(ERROR, "EvalPlanQual doesn't support locking rowmarks");
  
     /* if child rel, must check whether it produced this row */
     if (erm->rti != erm->prti)
     {
         Oid         tableoid;
  
         datum = ExecGetJunkAttribute(epqstate->origslot,
                                      earm->toidAttNo,
                                      &isNull);
         /* non-locked rels could be on the inside of outer joins */
         if (isNull)
             return false;
  
         tableoid = DatumGetObjectId(datum);
  
         Assert(OidIsValid(erm->relid));
         if (tableoid != erm->relid)
         {
             /* this child is inactive right now */
             return false;
         }
     }
  
     if (erm->markType == ROW_MARK_REFERENCE)
     {
         Assert(erm->relation != NULL);
  
         /* fetch the tuple's ctid */
         datum = ExecGetJunkAttribute(epqstate->origslot,
                                      earm->ctidAttNo,
                                      &isNull);
         /* non-locked rels could be on the inside of outer joins */
         if (isNull)
             return false;
  
         /* fetch requests on foreign tables must be passed to their FDW */
         if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
         {
             FdwRoutine *fdwroutine;
             bool        updated = false;
  
             fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
             /* this should have been checked already, but let's be safe */
             if (fdwroutine->RefetchForeignRow == NULL)
                 ereport(ERROR,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("cannot lock rows in foreign table \"%s\"",
                                 RelationGetRelationName(erm->relation))));
  
             fdwroutine->RefetchForeignRow(epqstate->recheckestate,
                                           erm,
                                           datum,
                                           slot,
                                           &updated);
             if (TupIsNull(slot))
                 elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
  
             /*
              * Ideally we'd insist on updated == false here, but that assumes
              * that FDWs can track that exactly, which they might not be able
              * to.  So just ignore the flag.
              */
             return true;
         }
         else
         {
             /* ordinary table, fetch the tuple */
             if (!table_tuple_fetch_row_version(erm->relation,
                                                (ItemPointer) DatumGetPointer(datum),
                                                SnapshotAny, slot))
                 elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
             return true;
         }
     }
     else
     {
         Assert(erm->markType == ROW_MARK_COPY);
  
         /* fetch the whole-row Var for the relation */
         datum = ExecGetJunkAttribute(epqstate->origslot,
                                      earm->wholeAttNo,
                                      &isNull);
         /* non-locked rels could be on the inside of outer joins */
         if (isNull)
             return false;
  
         ExecStoreHeapTupleDatum(datum, slot);
         return true;
     }
 }

References Assert(), ExecAuxRowMark::ctidAttNo, DatumGetObjectId(), DatumGetPointer(), elog(), ereport, errcode(), errmsg(), ERROR, ExecGetJunkAttribute(), ExecStoreHeapTupleDatum(), GetFdwRoutineForRelation(), ExecRowMark::markType, OidIsValid, EPQState::origslot, ExecRowMark::prti, RelationData::rd_rel, EPQState::recheckestate, FdwRoutine::RefetchForeignRow, ExecRowMark::relation, RelationGetRelationName, ExecRowMark::relid, EPQState::relsubs_rowmark, ROW_MARK_COPY, ROW_MARK_REFERENCE, ExecAuxRowMark::rowmark, RowMarkRequiresRowShareLock, ExecRowMark::rti, SnapshotAny, table_tuple_fetch_row_version(), ExecAuxRowMark::toidAttNo, TupIsNull, and ExecAuxRowMark::wholeAttNo.

Referenced by ExecScanFetch().

◆ EvalPlanQualInit()

void EvalPlanQualInit	(	EPQState *	epqstate,
		EState *	parentestate,
		Plan *	subplan,
		List *	auxrowmarks,
		int	epqParam,
		List *	resultRelations
	)

Definition at line 2563 of file execMain.c.

 {
     Index       rtsize = parentestate->es_range_table_size;
  
     /* initialize data not changing over EPQState's lifetime */
     epqstate->parentestate = parentestate;
     epqstate->epqParam = epqParam;
     epqstate->resultRelations = resultRelations;
  
     /*
      * Allocate space to reference a slot for each potential rti - do so now
      * rather than in EvalPlanQualBegin(), as done for other dynamically
      * allocated resources, so EvalPlanQualSlot() can be used to hold tuples
      * that *may* need EPQ later, without forcing the overhead of
      * EvalPlanQualBegin().
      */
     epqstate->tuple_table = NIL;
     epqstate->relsubs_slot = (TupleTableSlot **)
         palloc0(rtsize * sizeof(TupleTableSlot *));
  
     /* ... and remember data that EvalPlanQualBegin will need */
     epqstate->plan = subplan;
     epqstate->arowMarks = auxrowmarks;
  
     /* ... and mark the EPQ state inactive */
     epqstate->origslot = NULL;
     epqstate->recheckestate = NULL;
     epqstate->recheckplanstate = NULL;
     epqstate->relsubs_rowmark = NULL;
     epqstate->relsubs_done = NULL;
     epqstate->relsubs_blocked = NULL;
 }

References EPQState::arowMarks, EPQState::epqParam, EState::es_range_table_size, NIL, EPQState::origslot, palloc0(), EPQState::parentestate, EPQState::plan, EPQState::recheckestate, EPQState::recheckplanstate, EPQState::relsubs_blocked, EPQState::relsubs_done, EPQState::relsubs_rowmark, EPQState::relsubs_slot, EPQState::resultRelations, and EPQState::tuple_table.

Referenced by apply_handle_delete_internal(), apply_handle_tuple_routing(), apply_handle_update_internal(), ExecInitLockRows(), and ExecInitModifyTable().

◆ EvalPlanQualNext()

TupleTableSlot* EvalPlanQualNext ( EPQState * epqstate )

Definition at line 2759 of file execMain.c.

 {
     MemoryContext oldcontext;
     TupleTableSlot *slot;
  
     oldcontext = MemoryContextSwitchTo(epqstate->recheckestate->es_query_cxt);
     slot = ExecProcNode(epqstate->recheckplanstate);
     MemoryContextSwitchTo(oldcontext);
  
     return slot;
 }

References EState::es_query_cxt, ExecProcNode(), MemoryContextSwitchTo(), EPQState::recheckestate, and EPQState::recheckplanstate.

Referenced by EvalPlanQual(), and ExecLockRows().

◆ EvalPlanQualSetPlan()

void EvalPlanQualSetPlan	(	EPQState *	epqstate,
		Plan *	subplan,
		List *	auxrowmarks
	)

Definition at line 2605 of file execMain.c.

 {
     /* If we have a live EPQ query, shut it down */
     EvalPlanQualEnd(epqstate);
     /* And set/change the plan pointer */
     epqstate->plan = subplan;
     /* The rowmarks depend on the plan, too */
     epqstate->arowMarks = auxrowmarks;
 }

References EPQState::arowMarks, EvalPlanQualEnd(), and EPQState::plan.

Referenced by ExecInitModifyTable().

◆ EvalPlanQualSlot()

TupleTableSlot* EvalPlanQualSlot	(	EPQState *	epqstate,
		Relation	relation,
		Index	rti
	)

Definition at line 2622 of file execMain.c.

 {
     TupleTableSlot **slot;
  
     Assert(relation);
     Assert(rti > 0 && rti <= epqstate->parentestate->es_range_table_size);
     slot = &epqstate->relsubs_slot[rti - 1];
  
     if (*slot == NULL)
     {
         MemoryContext oldcontext;
  
         oldcontext = MemoryContextSwitchTo(epqstate->parentestate->es_query_cxt);
         *slot = table_slot_create(relation, &epqstate->tuple_table);
         MemoryContextSwitchTo(oldcontext);
     }
  
     return *slot;
 }

References Assert(), EState::es_query_cxt, MemoryContextSwitchTo(), EPQState::parentestate, EPQState::relsubs_slot, table_slot_create(), and EPQState::tuple_table.

Referenced by EvalPlanQual(), ExecDelete(), ExecLockRows(), ExecMergeMatched(), and ExecUpdate().

◆ exec_rt_fetch()

static RangeTblEntry* exec_rt_fetch	(	Index	rti,
		EState *	estate
	)

inlinestatic

Definition at line 586 of file executor.h.

 {
     return (RangeTblEntry *) list_nth(estate->es_range_table, rti - 1);
 }

References EState::es_range_table, and list_nth().

Referenced by conversion_error_callback(), ExecEvalWholeRowVar(), ExecGetRangeTableRelation(), ExecInitBitmapIndexScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), GetResultRTEPermissionInfo(), InitPlan(), postgresBeginForeignInsert(), postgresBeginForeignModify(), and postgresBeginForeignScan().

◆ ExecAssignExprContext()

void ExecAssignExprContext	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 488 of file execUtils.c.

 {
     planstate->ps_ExprContext = CreateExprContext(estate);
 }

References CreateExprContext(), and PlanState::ps_ExprContext.

Referenced by ExecInitAgg(), ExecInitBitmapHeapScan(), ExecInitBitmapIndexScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitInsertProjection(), ExecInitLimit(), ExecInitMemoize(), ExecInitMerge(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitPartitionPruning(), ExecInitProjectSet(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitUpdateProjection(), ExecInitValuesScan(), ExecInitWindowAgg(), and ExecInitWorkTableScan().

◆ ExecAssignProjectionInfo()

void ExecAssignProjectionInfo	(	PlanState *	planstate,
		TupleDesc	inputDesc
	)

Definition at line 543 of file execUtils.c.

 {
     planstate->ps_ProjInfo =
         ExecBuildProjectionInfo(planstate->plan->targetlist,
                                 planstate->ps_ExprContext,
                                 planstate->ps_ResultTupleSlot,
                                 planstate,
                                 inputDesc);
 }

References ExecBuildProjectionInfo(), PlanState::plan, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::ps_ResultTupleSlot, and Plan::targetlist.

Referenced by ExecConditionalAssignProjectionInfo(), ExecInitAgg(), ExecInitGroup(), ExecInitHashJoin(), ExecInitMergeJoin(), ExecInitNestLoop(), ExecInitResult(), and ExecInitWindowAgg().

◆ ExecAssignScanProjectionInfo()

void ExecAssignScanProjectionInfo ( ScanState * node )

Definition at line 271 of file execScan.c.

 {
     Scan       *scan = (Scan *) node->ps.plan;
     TupleDesc   tupdesc = node->ss_ScanTupleSlot->tts_tupleDescriptor;
  
     ExecConditionalAssignProjectionInfo(&node->ps, tupdesc, scan->scanrelid);
 }

References ExecConditionalAssignProjectionInfo(), PlanState::plan, ScanState::ps, Scan::scanrelid, ScanState::ss_ScanTupleSlot, and TupleTableSlot::tts_tupleDescriptor.

Referenced by ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitFunctionScan(), ExecInitIndexScan(), ExecInitNamedTuplestoreScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecWorkTableScan().

◆ ExecAssignScanProjectionInfoWithVarno()

void ExecAssignScanProjectionInfoWithVarno	(	ScanState *	node,
		int	varno
	)

Definition at line 284 of file execScan.c.

 {
     TupleDesc   tupdesc = node->ss_ScanTupleSlot->tts_tupleDescriptor;
  
     ExecConditionalAssignProjectionInfo(&node->ps, tupdesc, varno);
 }

References ExecConditionalAssignProjectionInfo(), ScanState::ps, ScanState::ss_ScanTupleSlot, and TupleTableSlot::tts_tupleDescriptor.

Referenced by ExecInitCustomScan(), ExecInitForeignScan(), and ExecInitIndexOnlyScan().

◆ ExecAssignScanType()

void ExecAssignScanType	(	ScanState *	scanstate,
		TupleDesc	tupDesc
	)

Definition at line 652 of file execUtils.c.

 {
     TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
  
     ExecSetSlotDescriptor(slot, tupDesc);
 }

References ExecSetSlotDescriptor(), and ScanState::ss_ScanTupleSlot.

Referenced by ExecWorkTableScan().

◆ ExecBuildAggTrans()

ExprState* ExecBuildAggTrans	(	AggState *	aggstate,
		struct AggStatePerPhaseData *	phase,
		bool	doSort,
		bool	doHash,
		bool	nullcheck
	)

◆ ExecBuildAuxRowMark()

ExecAuxRowMark* ExecBuildAuxRowMark	(	ExecRowMark *	erm,
		List *	targetlist
	)

Definition at line 2424 of file execMain.c.

 {
     ExecAuxRowMark *aerm = (ExecAuxRowMark *) palloc0(sizeof(ExecAuxRowMark));
     char        resname[32];
  
     aerm->rowmark = erm;
  
     /* Look up the resjunk columns associated with this rowmark */
     if (erm->markType != ROW_MARK_COPY)
     {
         /* need ctid for all methods other than COPY */
         snprintf(resname, sizeof(resname), "ctid%u", erm->rowmarkId);
         aerm->ctidAttNo = ExecFindJunkAttributeInTlist(targetlist,
                                                        resname);
         if (!AttributeNumberIsValid(aerm->ctidAttNo))
             elog(ERROR, "could not find junk %s column", resname);
     }
     else
     {
         /* need wholerow if COPY */
         snprintf(resname, sizeof(resname), "wholerow%u", erm->rowmarkId);
         aerm->wholeAttNo = ExecFindJunkAttributeInTlist(targetlist,
                                                         resname);
         if (!AttributeNumberIsValid(aerm->wholeAttNo))
             elog(ERROR, "could not find junk %s column", resname);
     }
  
     /* if child rel, need tableoid */
     if (erm->rti != erm->prti)
     {
         snprintf(resname, sizeof(resname), "tableoid%u", erm->rowmarkId);
         aerm->toidAttNo = ExecFindJunkAttributeInTlist(targetlist,
                                                        resname);
         if (!AttributeNumberIsValid(aerm->toidAttNo))
             elog(ERROR, "could not find junk %s column", resname);
     }
  
     return aerm;
 }

References AttributeNumberIsValid, ExecAuxRowMark::ctidAttNo, elog(), ERROR, ExecFindJunkAttributeInTlist(), ExecRowMark::markType, palloc0(), ExecRowMark::prti, ROW_MARK_COPY, ExecAuxRowMark::rowmark, ExecRowMark::rowmarkId, ExecRowMark::rti, snprintf, ExecAuxRowMark::toidAttNo, and ExecAuxRowMark::wholeAttNo.

Referenced by ExecInitLockRows(), and ExecInitModifyTable().

◆ ExecBuildGroupingEqual()

ExprState* ExecBuildGroupingEqual	(	TupleDesc	ldesc,
		TupleDesc	rdesc,
		const TupleTableSlotOps *	lops,
		const TupleTableSlotOps *	rops,
		int	numCols,
		const AttrNumber *	keyColIdx,
		const Oid *	eqfunctions,
		const Oid *	collations,
		PlanState *	parent
	)

Definition at line 3907 of file execExpr.c.

 {
     ExprState  *state = makeNode(ExprState);
     ExprEvalStep scratch = {0};
     int         maxatt = -1;
     List       *adjust_jumps = NIL;
     ListCell   *lc;
  
     /*
      * When no columns are actually compared, the result's always true. See
      * special case in ExecQual().
      */
     if (numCols == 0)
         return NULL;
  
     state->expr = NULL;
     state->flags = EEO_FLAG_IS_QUAL;
     state->parent = parent;
  
     scratch.resvalue = &state->resvalue;
     scratch.resnull = &state->resnull;
  
     /* compute max needed attribute */
     for (int natt = 0; natt < numCols; natt++)
     {
         int         attno = keyColIdx[natt];
  
         if (attno > maxatt)
             maxatt = attno;
     }
     Assert(maxatt >= 0);
  
     /* push deform steps */
     scratch.opcode = EEOP_INNER_FETCHSOME;
     scratch.d.fetch.last_var = maxatt;
     scratch.d.fetch.fixed = false;
     scratch.d.fetch.known_desc = ldesc;
     scratch.d.fetch.kind = lops;
     if (ExecComputeSlotInfo(state, &scratch))
         ExprEvalPushStep(state, &scratch);
  
     scratch.opcode = EEOP_OUTER_FETCHSOME;
     scratch.d.fetch.last_var = maxatt;
     scratch.d.fetch.fixed = false;
     scratch.d.fetch.known_desc = rdesc;
     scratch.d.fetch.kind = rops;
     if (ExecComputeSlotInfo(state, &scratch))
         ExprEvalPushStep(state, &scratch);
  
     /*
      * Start comparing at the last field (least significant sort key). That's
      * the most likely to be different if we are dealing with sorted input.
      */
     for (int natt = numCols; --natt >= 0;)
     {
         int         attno = keyColIdx[natt];
         Form_pg_attribute latt = TupleDescAttr(ldesc, attno - 1);
         Form_pg_attribute ratt = TupleDescAttr(rdesc, attno - 1);
         Oid         foid = eqfunctions[natt];
         Oid         collid = collations[natt];
         FmgrInfo   *finfo;
         FunctionCallInfo fcinfo;
         AclResult   aclresult;
  
         /* Check permission to call function */
         aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
  
         InvokeFunctionExecuteHook(foid);
  
         /* Set up the primary fmgr lookup information */
         finfo = palloc0(sizeof(FmgrInfo));
         fcinfo = palloc0(SizeForFunctionCallInfo(2));
         fmgr_info(foid, finfo);
         fmgr_info_set_expr(NULL, finfo);
         InitFunctionCallInfoData(*fcinfo, finfo, 2,
                                  collid, NULL, NULL);
  
         /* left arg */
         scratch.opcode = EEOP_INNER_VAR;
         scratch.d.var.attnum = attno - 1;
         scratch.d.var.vartype = latt->atttypid;
         scratch.resvalue = &fcinfo->args[0].value;
         scratch.resnull = &fcinfo->args[0].isnull;
         ExprEvalPushStep(state, &scratch);
  
         /* right arg */
         scratch.opcode = EEOP_OUTER_VAR;
         scratch.d.var.attnum = attno - 1;
         scratch.d.var.vartype = ratt->atttypid;
         scratch.resvalue = &fcinfo->args[1].value;
         scratch.resnull = &fcinfo->args[1].isnull;
         ExprEvalPushStep(state, &scratch);
  
         /* evaluate distinctness */
         scratch.opcode = EEOP_NOT_DISTINCT;
         scratch.d.func.finfo = finfo;
         scratch.d.func.fcinfo_data = fcinfo;
         scratch.d.func.fn_addr = finfo->fn_addr;
         scratch.d.func.nargs = 2;
         scratch.resvalue = &state->resvalue;
         scratch.resnull = &state->resnull;
         ExprEvalPushStep(state, &scratch);
  
         /* then emit EEOP_QUAL to detect if result is false (or null) */
         scratch.opcode = EEOP_QUAL;
         scratch.d.qualexpr.jumpdone = -1;
         scratch.resvalue = &state->resvalue;
         scratch.resnull = &state->resnull;
         ExprEvalPushStep(state, &scratch);
         adjust_jumps = lappend_int(adjust_jumps,
                                    state->steps_len - 1);
     }
  
     /* adjust jump targets */
     foreach(lc, adjust_jumps)
     {
         ExprEvalStep *as = &state->steps[lfirst_int(lc)];
  
         Assert(as->opcode == EEOP_QUAL);
         Assert(as->d.qualexpr.jumpdone == -1);
         as->d.qualexpr.jumpdone = state->steps_len;
     }
  
     scratch.resvalue = NULL;
     scratch.resnull = NULL;
     scratch.opcode = EEOP_DONE;
     ExprEvalPushStep(state, &scratch);
  
     ExecReadyExpr(state);
  
     return state;
 }

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, FunctionCallInfoBaseData::args, Assert(), collid, ExprEvalStep::d, EEO_FLAG_IS_QUAL, EEOP_DONE, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, EEOP_NOT_DISTINCT, EEOP_OUTER_FETCHSOME, EEOP_OUTER_VAR, EEOP_QUAL, ExecComputeSlotInfo(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fetch, fmgr_info(), fmgr_info_set_expr, FmgrInfo::fn_addr, ExprEvalStep::func, get_func_name(), GetUserId(), InitFunctionCallInfoData, InvokeFunctionExecuteHook, NullableDatum::isnull, lappend_int(), lfirst_int, makeNode, NIL, object_aclcheck(), OBJECT_FUNCTION, ExprEvalStep::opcode, palloc0(), ExprEvalStep::qualexpr, ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, TupleDescAttr, NullableDatum::value, and ExprEvalStep::var.

Referenced by BuildTupleHashTableExt(), ExecInitSubPlan(), and execTuplesMatchPrepare().

◆ ExecBuildParamSetEqual()

ExprState* ExecBuildParamSetEqual	(	TupleDesc	desc,
		const TupleTableSlotOps *	lops,
		const TupleTableSlotOps *	rops,
		const Oid *	eqfunctions,
		const Oid *	collations,
		const List *	param_exprs,
		PlanState *	parent
	)

Definition at line 4064 of file execExpr.c.

 {
     ExprState  *state = makeNode(ExprState);
     ExprEvalStep scratch = {0};
     int         maxatt = list_length(param_exprs);
     List       *adjust_jumps = NIL;
     ListCell   *lc;
  
     state->expr = NULL;
     state->flags = EEO_FLAG_IS_QUAL;
     state->parent = parent;
  
     scratch.resvalue = &state->resvalue;
     scratch.resnull = &state->resnull;
  
     /* push deform steps */
     scratch.opcode = EEOP_INNER_FETCHSOME;
     scratch.d.fetch.last_var = maxatt;
     scratch.d.fetch.fixed = false;
     scratch.d.fetch.known_desc = desc;
     scratch.d.fetch.kind = lops;
     if (ExecComputeSlotInfo(state, &scratch))
         ExprEvalPushStep(state, &scratch);
  
     scratch.opcode = EEOP_OUTER_FETCHSOME;
     scratch.d.fetch.last_var = maxatt;
     scratch.d.fetch.fixed = false;
     scratch.d.fetch.known_desc = desc;
     scratch.d.fetch.kind = rops;
     if (ExecComputeSlotInfo(state, &scratch))
         ExprEvalPushStep(state, &scratch);
  
     for (int attno = 0; attno < maxatt; attno++)
     {
         Form_pg_attribute att = TupleDescAttr(desc, attno);
         Oid         foid = eqfunctions[attno];
         Oid         collid = collations[attno];
         FmgrInfo   *finfo;
         FunctionCallInfo fcinfo;
         AclResult   aclresult;
  
         /* Check permission to call function */
         aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
  
         InvokeFunctionExecuteHook(foid);
  
         /* Set up the primary fmgr lookup information */
         finfo = palloc0(sizeof(FmgrInfo));
         fcinfo = palloc0(SizeForFunctionCallInfo(2));
         fmgr_info(foid, finfo);
         fmgr_info_set_expr(NULL, finfo);
         InitFunctionCallInfoData(*fcinfo, finfo, 2,
                                  collid, NULL, NULL);
  
         /* left arg */
         scratch.opcode = EEOP_INNER_VAR;
         scratch.d.var.attnum = attno;
         scratch.d.var.vartype = att->atttypid;
         scratch.resvalue = &fcinfo->args[0].value;
         scratch.resnull = &fcinfo->args[0].isnull;
         ExprEvalPushStep(state, &scratch);
  
         /* right arg */
         scratch.opcode = EEOP_OUTER_VAR;
         scratch.d.var.attnum = attno;
         scratch.d.var.vartype = att->atttypid;
         scratch.resvalue = &fcinfo->args[1].value;
         scratch.resnull = &fcinfo->args[1].isnull;
         ExprEvalPushStep(state, &scratch);
  
         /* evaluate distinctness */
         scratch.opcode = EEOP_NOT_DISTINCT;
         scratch.d.func.finfo = finfo;
         scratch.d.func.fcinfo_data = fcinfo;
         scratch.d.func.fn_addr = finfo->fn_addr;
         scratch.d.func.nargs = 2;
         scratch.resvalue = &state->resvalue;
         scratch.resnull = &state->resnull;
         ExprEvalPushStep(state, &scratch);
  
         /* then emit EEOP_QUAL to detect if result is false (or null) */
         scratch.opcode = EEOP_QUAL;
         scratch.d.qualexpr.jumpdone = -1;
         scratch.resvalue = &state->resvalue;
         scratch.resnull = &state->resnull;
         ExprEvalPushStep(state, &scratch);
         adjust_jumps = lappend_int(adjust_jumps,
                                    state->steps_len - 1);
     }
  
     /* adjust jump targets */
     foreach(lc, adjust_jumps)
     {
         ExprEvalStep *as = &state->steps[lfirst_int(lc)];
  
         Assert(as->opcode == EEOP_QUAL);
         Assert(as->d.qualexpr.jumpdone == -1);
         as->d.qualexpr.jumpdone = state->steps_len;
     }
  
     scratch.resvalue = NULL;
     scratch.resnull = NULL;
     scratch.opcode = EEOP_DONE;
     ExprEvalPushStep(state, &scratch);
  
     ExecReadyExpr(state);
  
     return state;
 }

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, FunctionCallInfoBaseData::args, Assert(), collid, ExprEvalStep::d, EEO_FLAG_IS_QUAL, EEOP_DONE, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, EEOP_NOT_DISTINCT, EEOP_OUTER_FETCHSOME, EEOP_OUTER_VAR, EEOP_QUAL, ExecComputeSlotInfo(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fetch, fmgr_info(), fmgr_info_set_expr, FmgrInfo::fn_addr, ExprEvalStep::func, get_func_name(), GetUserId(), InitFunctionCallInfoData, InvokeFunctionExecuteHook, NullableDatum::isnull, lappend_int(), lfirst_int, list_length(), makeNode, NIL, object_aclcheck(), OBJECT_FUNCTION, ExprEvalStep::opcode, palloc0(), ExprEvalStep::qualexpr, ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, TupleDescAttr, NullableDatum::value, and ExprEvalStep::var.

Referenced by ExecInitMemoize().

◆ ExecBuildProjectionInfo()

ProjectionInfo* ExecBuildProjectionInfo	(	List *	targetList,
		ExprContext *	econtext,
		TupleTableSlot *	slot,
		PlanState *	parent,
		TupleDesc	inputDesc
	)

Definition at line 358 of file execExpr.c.

 {
     ProjectionInfo *projInfo = makeNode(ProjectionInfo);
     ExprState  *state;
     ExprEvalStep scratch = {0};
     ListCell   *lc;
  
     projInfo->pi_exprContext = econtext;
     /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
     projInfo->pi_state.type = T_ExprState;
     state = &projInfo->pi_state;
     state->expr = (Expr *) targetList;
     state->parent = parent;
     state->ext_params = NULL;
  
     state->resultslot = slot;
  
     /* Insert setup steps as needed */
     ExecCreateExprSetupSteps(state, (Node *) targetList);
  
     /* Now compile each tlist column */
     foreach(lc, targetList)
     {
         TargetEntry *tle = lfirst_node(TargetEntry, lc);
         Var        *variable = NULL;
         AttrNumber  attnum = 0;
         bool        isSafeVar = false;
  
         /*
          * If tlist expression is a safe non-system Var, use the fast-path
          * ASSIGN_*_VAR opcodes.  "Safe" means that we don't need to apply
          * CheckVarSlotCompatibility() during plan startup.  If a source slot
          * was provided, we make the equivalent tests here; if a slot was not
          * provided, we assume that no check is needed because we're dealing
          * with a non-relation-scan-level expression.
          */
         if (tle->expr != NULL &&
             IsA(tle->expr, Var) &&
             ((Var *) tle->expr)->varattno > 0)
         {
             /* Non-system Var, but how safe is it? */
             variable = (Var *) tle->expr;
             attnum = variable->varattno;
  
             if (inputDesc == NULL)
                 isSafeVar = true;   /* can't check, just assume OK */
             else if (attnum <= inputDesc->natts)
             {
                 Form_pg_attribute attr = TupleDescAttr(inputDesc, attnum - 1);
  
                 /*
                  * If user attribute is dropped or has a type mismatch, don't
                  * use ASSIGN_*_VAR.  Instead let the normal expression
                  * machinery handle it (which'll possibly error out).
                  */
                 if (!attr->attisdropped && variable->vartype == attr->atttypid)
                 {
                     isSafeVar = true;
                 }
             }
         }
  
         if (isSafeVar)
         {
             /* Fast-path: just generate an EEOP_ASSIGN_*_VAR step */
             switch (variable->varno)
             {
                 case INNER_VAR:
                     /* get the tuple from the inner node */
                     scratch.opcode = EEOP_ASSIGN_INNER_VAR;
                     break;
  
                 case OUTER_VAR:
                     /* get the tuple from the outer node */
                     scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
                     break;
  
                     /* INDEX_VAR is handled by default case */
  
                 default:
                     /* get the tuple from the relation being scanned */
                     scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
                     break;
             }
  
             scratch.d.assign_var.attnum = attnum - 1;
             scratch.d.assign_var.resultnum = tle->resno - 1;
             ExprEvalPushStep(state, &scratch);
         }
         else
         {
             /*
              * Otherwise, compile the column expression normally.
              *
              * We can't tell the expression to evaluate directly into the
              * result slot, as the result slot (and the exprstate for that
              * matter) can change between executions.  We instead evaluate
              * into the ExprState's resvalue/resnull and then move.
              */
             ExecInitExprRec(tle->expr, state,
                             &state->resvalue, &state->resnull);
  
             /*
              * Column might be referenced multiple times in upper nodes, so
              * force value to R/O - but only if it could be an expanded datum.
              */
             if (get_typlen(exprType((Node *) tle->expr)) == -1)
                 scratch.opcode = EEOP_ASSIGN_TMP_MAKE_RO;
             else
                 scratch.opcode = EEOP_ASSIGN_TMP;
             scratch.d.assign_tmp.resultnum = tle->resno - 1;
             ExprEvalPushStep(state, &scratch);
         }
     }
  
     scratch.opcode = EEOP_DONE;
     ExprEvalPushStep(state, &scratch);
  
     ExecReadyExpr(state);
  
     return projInfo;
 }

References ExprEvalStep::assign_tmp, ExprEvalStep::assign_var, attnum, ExprEvalStep::d, EEOP_ASSIGN_INNER_VAR, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_ASSIGN_TMP, EEOP_ASSIGN_TMP_MAKE_RO, EEOP_DONE, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), TargetEntry::expr, ExprEvalPushStep(), exprType(), get_typlen(), if(), INNER_VAR, IsA, lfirst_node, makeNode, ExprEvalStep::opcode, OUTER_VAR, ProjectionInfo::pi_exprContext, ProjectionInfo::pi_state, TargetEntry::resno, TupleDescAttr, and ExprState::type.

Referenced by ExecAssignProjectionInfo(), ExecInitInsertProjection(), ExecInitMerge(), ExecInitModifyTable(), ExecInitPartitionInfo(), and ExecInitSubPlan().

◆ ExecBuildUpdateProjection()

ProjectionInfo* ExecBuildUpdateProjection	(	List *	targetList,
		bool	evalTargetList,
		List *	targetColnos,
		TupleDesc	relDesc,
		ExprContext *	econtext,
		TupleTableSlot *	slot,
		PlanState *	parent
	)

Definition at line 518 of file execExpr.c.

 {
     ProjectionInfo *projInfo = makeNode(ProjectionInfo);
     ExprState  *state;
     int         nAssignableCols;
     bool        sawJunk;
     Bitmapset  *assignedCols;
     ExprSetupInfo deform = {0, 0, 0, NIL};
     ExprEvalStep scratch = {0};
     int         outerattnum;
     ListCell   *lc,
                *lc2;
  
     projInfo->pi_exprContext = econtext;
     /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
     projInfo->pi_state.type = T_ExprState;
     state = &projInfo->pi_state;
     if (evalTargetList)
         state->expr = (Expr *) targetList;
     else
         state->expr = NULL;     /* not used */
     state->parent = parent;
     state->ext_params = NULL;
  
     state->resultslot = slot;
  
     /*
      * Examine the targetList to see how many non-junk columns there are, and
      * to verify that the non-junk columns come before the junk ones.
      */
     nAssignableCols = 0;
     sawJunk = false;
     foreach(lc, targetList)
     {
         TargetEntry *tle = lfirst_node(TargetEntry, lc);
  
         if (tle->resjunk)
             sawJunk = true;
         else
         {
             if (sawJunk)
                 elog(ERROR, "subplan target list is out of order");
             nAssignableCols++;
         }
     }
  
     /* We should have one targetColnos entry per non-junk column */
     if (nAssignableCols != list_length(targetColnos))
         elog(ERROR, "targetColnos does not match subplan target list");
  
     /*
      * Build a bitmapset of the columns in targetColnos.  (We could just use
      * list_member_int() tests, but that risks O(N^2) behavior with many
      * columns.)
      */
     assignedCols = NULL;
     foreach(lc, targetColnos)
     {
         AttrNumber  targetattnum = lfirst_int(lc);
  
         assignedCols = bms_add_member(assignedCols, targetattnum);
     }
  
     /*
      * We need to insert EEOP_*_FETCHSOME steps to ensure the input tuples are
      * sufficiently deconstructed.  The scan tuple must be deconstructed at
      * least as far as the last old column we need.
      */
     for (int attnum = relDesc->natts; attnum > 0; attnum--)
     {
         Form_pg_attribute attr = TupleDescAttr(relDesc, attnum - 1);
  
         if (attr->attisdropped)
             continue;
         if (bms_is_member(attnum, assignedCols))
             continue;
         deform.last_scan = attnum;
         break;
     }
  
     /*
      * If we're actually evaluating the tlist, incorporate its input
      * requirements too; otherwise, we'll just need to fetch the appropriate
      * number of columns of the "outer" tuple.
      */
     if (evalTargetList)
         expr_setup_walker((Node *) targetList, &deform);
     else
         deform.last_outer = nAssignableCols;
  
     ExecPushExprSetupSteps(state, &deform);
  
     /*
      * Now generate code to evaluate the tlist's assignable expressions or
      * fetch them from the outer tuple, incidentally validating that they'll
      * be of the right data type.  The checks above ensure that the forboth()
      * will iterate over exactly the non-junk columns.  Note that we don't
      * bother evaluating any remaining resjunk columns.
      */
     outerattnum = 0;
     forboth(lc, targetList, lc2, targetColnos)
     {
         TargetEntry *tle = lfirst_node(TargetEntry, lc);
         AttrNumber  targetattnum = lfirst_int(lc2);
         Form_pg_attribute attr;
  
         Assert(!tle->resjunk);
  
         /*
          * Apply sanity checks comparable to ExecCheckPlanOutput().
          */
         if (targetattnum <= 0 || targetattnum > relDesc->natts)
             ereport(ERROR,
                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                      errmsg("table row type and query-specified row type do not match"),
                      errdetail("Query has too many columns.")));
         attr = TupleDescAttr(relDesc, targetattnum - 1);
  
         if (attr->attisdropped)
             ereport(ERROR,
                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                      errmsg("table row type and query-specified row type do not match"),
                      errdetail("Query provides a value for a dropped column at ordinal position %d.",
                                targetattnum)));
         if (exprType((Node *) tle->expr) != attr->atttypid)
             ereport(ERROR,
                     (errcode(ERRCODE_DATATYPE_MISMATCH),
                      errmsg("table row type and query-specified row type do not match"),
                      errdetail("Table has type %s at ordinal position %d, but query expects %s.",
                                format_type_be(attr->atttypid),
                                targetattnum,
                                format_type_be(exprType((Node *) tle->expr)))));
  
         /* OK, generate code to perform the assignment. */
         if (evalTargetList)
         {
             /*
              * We must evaluate the TLE's expression and assign it.  We do not
              * bother jumping through hoops for "safe" Vars like
              * ExecBuildProjectionInfo does; this is a relatively less-used
              * path and it doesn't seem worth expending code for that.
              */
             ExecInitExprRec(tle->expr, state,
                             &state->resvalue, &state->resnull);
             /* Needn't worry about read-only-ness here, either. */
             scratch.opcode = EEOP_ASSIGN_TMP;
             scratch.d.assign_tmp.resultnum = targetattnum - 1;
             ExprEvalPushStep(state, &scratch);
         }
         else
         {
             /* Just assign from the outer tuple. */
             scratch.opcode = EEOP_ASSIGN_OUTER_VAR;
             scratch.d.assign_var.attnum = outerattnum;
             scratch.d.assign_var.resultnum = targetattnum - 1;
             ExprEvalPushStep(state, &scratch);
         }
         outerattnum++;
     }
  
     /*
      * Now generate code to copy over any old columns that were not assigned
      * to, and to ensure that dropped columns are set to NULL.
      */
     for (int attnum = 1; attnum <= relDesc->natts; attnum++)
     {
         Form_pg_attribute attr = TupleDescAttr(relDesc, attnum - 1);
  
         if (attr->attisdropped)
         {
             /* Put a null into the ExprState's resvalue/resnull ... */
             scratch.opcode = EEOP_CONST;
             scratch.resvalue = &state->resvalue;
             scratch.resnull = &state->resnull;
             scratch.d.constval.value = (Datum) 0;
             scratch.d.constval.isnull = true;
             ExprEvalPushStep(state, &scratch);
             /* ... then assign it to the result slot */
             scratch.opcode = EEOP_ASSIGN_TMP;
             scratch.d.assign_tmp.resultnum = attnum - 1;
             ExprEvalPushStep(state, &scratch);
         }
         else if (!bms_is_member(attnum, assignedCols))
         {
             /* Certainly the right type, so needn't check */
             scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
             scratch.d.assign_var.attnum = attnum - 1;
             scratch.d.assign_var.resultnum = attnum - 1;
             ExprEvalPushStep(state, &scratch);
         }
     }
  
     scratch.opcode = EEOP_DONE;
     ExprEvalPushStep(state, &scratch);
  
     ExecReadyExpr(state);
  
     return projInfo;
 }

References Assert(), ExprEvalStep::assign_tmp, ExprEvalStep::assign_var, attnum, bms_add_member(), bms_is_member(), ExprEvalStep::constval, ExprEvalStep::d, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_ASSIGN_TMP, EEOP_CONST, EEOP_DONE, elog(), ereport, errcode(), errdetail(), errmsg(), ERROR, ExecInitExprRec(), ExecPushExprSetupSteps(), ExecReadyExpr(), TargetEntry::expr, expr_setup_walker(), ExprEvalPushStep(), exprType(), forboth, format_type_be(), ExprSetupInfo::last_outer, ExprSetupInfo::last_scan, lfirst_int, lfirst_node, list_length(), makeNode, TupleDescData::natts, NIL, ExprEvalStep::opcode, ProjectionInfo::pi_exprContext, ProjectionInfo::pi_state, ExprEvalStep::resnull, ExprEvalStep::resvalue, TupleDescAttr, and ExprState::type.

Referenced by ExecInitMerge(), ExecInitModifyTable(), ExecInitPartitionInfo(), and ExecInitUpdateProjection().

◆ ExecCheck()

bool ExecCheck	(	ExprState *	state,
		ExprContext *	econtext
	)

Definition at line 843 of file execExpr.c.

 {
     Datum       ret;
     bool        isnull;
  
     /* short-circuit (here and in ExecInitCheck) for empty restriction list */
     if (state == NULL)
         return true;
  
     /* verify that expression was not compiled using ExecInitQual */
     Assert(!(state->flags & EEO_FLAG_IS_QUAL));
  
     ret = ExecEvalExprSwitchContext(state, econtext, &isnull);
  
     if (isnull)
         return true;
  
     return DatumGetBool(ret);
 }

References Assert(), DatumGetBool(), EEO_FLAG_IS_QUAL, and ExecEvalExprSwitchContext().

Referenced by ATRewriteTable(), check_default_partition_contents(), domain_check_input(), ExecPartitionCheck(), and ExecRelCheck().

◆ ExecCheckIndexConstraints()

bool ExecCheckIndexConstraints	(	ResultRelInfo *	resultRelInfo,
		TupleTableSlot *	slot,
		EState *	estate,
		ItemPointer	conflictTid,
		List *	arbiterIndexes
	)

Definition at line 527 of file execIndexing.c.

 {
     int         i;
     int         numIndices;
     RelationPtr relationDescs;
     Relation    heapRelation;
     IndexInfo **indexInfoArray;
     ExprContext *econtext;
     Datum       values[INDEX_MAX_KEYS];
     bool        isnull[INDEX_MAX_KEYS];
     ItemPointerData invalidItemPtr;
     bool        checkedIndex = false;
  
     ItemPointerSetInvalid(conflictTid);
     ItemPointerSetInvalid(&invalidItemPtr);
  
     /*
      * Get information from the result relation info structure.
      */
     numIndices = resultRelInfo->ri_NumIndices;
     relationDescs = resultRelInfo->ri_IndexRelationDescs;
     indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
     heapRelation = resultRelInfo->ri_RelationDesc;
  
     /*
      * We will use the EState's per-tuple context for evaluating predicates
      * and index expressions (creating it if it's not already there).
      */
     econtext = GetPerTupleExprContext(estate);
  
     /* Arrange for econtext's scan tuple to be the tuple under test */
     econtext->ecxt_scantuple = slot;
  
     /*
      * For each index, form index tuple and check if it satisfies the
      * constraint.
      */
     for (i = 0; i < numIndices; i++)
     {
         Relation    indexRelation = relationDescs[i];
         IndexInfo  *indexInfo;
         bool        satisfiesConstraint;
  
         if (indexRelation == NULL)
             continue;
  
         indexInfo = indexInfoArray[i];
  
         if (!indexInfo->ii_Unique && !indexInfo->ii_ExclusionOps)
             continue;
  
         /* If the index is marked as read-only, ignore it */
         if (!indexInfo->ii_ReadyForInserts)
             continue;
  
         /* When specific arbiter indexes requested, only examine them */
         if (arbiterIndexes != NIL &&
             !list_member_oid(arbiterIndexes,
                              indexRelation->rd_index->indexrelid))
             continue;
  
         if (!indexRelation->rd_index->indimmediate)
             ereport(ERROR,
                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                      errmsg("ON CONFLICT does not support deferrable unique constraints/exclusion constraints as arbiters"),
                      errtableconstraint(heapRelation,
                                         RelationGetRelationName(indexRelation))));
  
         checkedIndex = true;
  
         /* Check for partial index */
         if (indexInfo->ii_Predicate != NIL)
         {
             ExprState  *predicate;
  
             /*
              * If predicate state not set up yet, create it (in the estate's
              * per-query context)
              */
             predicate = indexInfo->ii_PredicateState;
             if (predicate == NULL)
             {
                 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
                 indexInfo->ii_PredicateState = predicate;
             }
  
             /* Skip this index-update if the predicate isn't satisfied */
             if (!ExecQual(predicate, econtext))
                 continue;
         }
  
         /*
          * FormIndexDatum fills in its values and isnull parameters with the
          * appropriate values for the column(s) of the index.
          */
         FormIndexDatum(indexInfo,
                        slot,
                        estate,
                        values,
                        isnull);
  
         satisfiesConstraint =
             check_exclusion_or_unique_constraint(heapRelation, indexRelation,
                                                  indexInfo, &invalidItemPtr,
                                                  values, isnull, estate, false,
                                                  CEOUC_WAIT, true,
                                                  conflictTid);
         if (!satisfiesConstraint)
             return false;
     }
  
     if (arbiterIndexes != NIL && !checkedIndex)
         elog(ERROR, "unexpected failure to find arbiter index");
  
     return true;
 }

References CEOUC_WAIT, check_exclusion_or_unique_constraint(), ExprContext::ecxt_scantuple, elog(), ereport, errcode(), errmsg(), ERROR, errtableconstraint(), ExecPrepareQual(), ExecQual(), FormIndexDatum(), GetPerTupleExprContext, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_ReadyForInserts, IndexInfo::ii_Unique, INDEX_MAX_KEYS, ItemPointerSetInvalid(), list_member_oid(), NIL, RelationData::rd_index, RelationGetRelationName, ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, and values.

Referenced by ExecInsert().

◆ ExecCheckPermissions()

bool ExecCheckPermissions	(	List *	rangeTable,
		List *	rteperminfos,
		bool	ereport_on_violation
	)

Definition at line 581 of file execMain.c.

 {
     ListCell   *l;
     bool        result = true;
  
 #ifdef USE_ASSERT_CHECKING
     Bitmapset  *indexset = NULL;
  
     /* Check that rteperminfos is consistent with rangeTable */
     foreach(l, rangeTable)
     {
         RangeTblEntry *rte = lfirst_node(RangeTblEntry, l);
  
         if (rte->perminfoindex != 0)
         {
             /* Sanity checks */
  
             /*
              * Only relation RTEs and subquery RTEs that were once relation
              * RTEs (views) have their perminfoindex set.
              */
             Assert(rte->rtekind == RTE_RELATION ||
                    (rte->rtekind == RTE_SUBQUERY &&
                     rte->relkind == RELKIND_VIEW));
  
             (void) getRTEPermissionInfo(rteperminfos, rte);
             /* Many-to-one mapping not allowed */
             Assert(!bms_is_member(rte->perminfoindex, indexset));
             indexset = bms_add_member(indexset, rte->perminfoindex);
         }
     }
  
     /* All rteperminfos are referenced */
     Assert(bms_num_members(indexset) == list_length(rteperminfos));
 #endif
  
     foreach(l, rteperminfos)
     {
         RTEPermissionInfo *perminfo = lfirst_node(RTEPermissionInfo, l);
  
         Assert(OidIsValid(perminfo->relid));
         result = ExecCheckOneRelPerms(perminfo);
         if (!result)
         {
             if (ereport_on_violation)
                 aclcheck_error(ACLCHECK_NO_PRIV,
                                get_relkind_objtype(get_rel_relkind(perminfo->relid)),
                                get_rel_name(perminfo->relid));
             return false;
         }
     }
  
     if (ExecutorCheckPerms_hook)
         result = (*ExecutorCheckPerms_hook) (rangeTable, rteperminfos,
                                              ereport_on_violation);
     return result;
 }

References aclcheck_error(), ACLCHECK_NO_PRIV, Assert(), bms_add_member(), bms_is_member(), bms_num_members(), ExecCheckOneRelPerms(), ExecutorCheckPerms_hook, get_rel_name(), get_rel_relkind(), get_relkind_objtype(), getRTEPermissionInfo(), lfirst_node, list_length(), OidIsValid, RangeTblEntry::perminfoindex, RTEPermissionInfo::relid, RangeTblEntry::relkind, RTE_RELATION, RTE_SUBQUERY, and RangeTblEntry::rtekind.

Referenced by DoCopy(), InitPlan(), and RI_Initial_Check().

◆ ExecCleanTargetListLength()

int ExecCleanTargetListLength ( List * targetlist )

Definition at line 1124 of file execUtils.c.

 {
     int         len = 0;
     ListCell   *tl;
  
     foreach(tl, targetlist)
     {
         TargetEntry *curTle = lfirst_node(TargetEntry, tl);
  
         if (!curTle->resjunk)
             len++;
     }
     return len;
 }

References len, and lfirst_node.

Referenced by ApplyRetrieveRule(), check_sql_fn_retval(), and ExecTypeFromTLInternal().

◆ ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL ( List * targetList )

Definition at line 1949 of file execTuples.c.

 {
     return ExecTypeFromTLInternal(targetList, true);
 }

References ExecTypeFromTLInternal().

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

◆ ExecCloseIndices()

void ExecCloseIndices ( ResultRelInfo * resultRelInfo )

Definition at line 231 of file execIndexing.c.

 {
     int         i;
     int         numIndices;
     RelationPtr indexDescs;
     IndexInfo **indexInfos;
  
     numIndices = resultRelInfo->ri_NumIndices;
     indexDescs = resultRelInfo->ri_IndexRelationDescs;
     indexInfos = resultRelInfo->ri_IndexRelationInfo;
  
     for (i = 0; i < numIndices; i++)
     {
         if (indexDescs[i] == NULL)
             continue;           /* shouldn't happen? */
  
         /* Give the index a chance to do some post-insert cleanup */
         index_insert_cleanup(indexDescs[i], indexInfos[i]);
  
         /* Drop lock acquired by ExecOpenIndices */
         index_close(indexDescs[i], RowExclusiveLock);
     }
  
     /*
      * XXX should free indexInfo array here too?  Currently we assume that
      * such stuff will be cleaned up automatically in FreeExecutorState.
      */
 }

References i, index_close(), index_insert_cleanup(), ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, and RowExclusiveLock.

Referenced by apply_handle_delete_internal(), apply_handle_insert_internal(), apply_handle_tuple_routing(), apply_handle_update_internal(), CatalogCloseIndexes(), ExecCleanupTupleRouting(), and ExecCloseResultRelations().

◆ ExecCloseRangeTableRelations()

void ExecCloseRangeTableRelations ( EState * estate )

Definition at line 1601 of file execMain.c.

 {
     int         i;
  
     for (i = 0; i < estate->es_range_table_size; i++)
     {
         if (estate->es_relations[i])
             table_close(estate->es_relations[i], NoLock);
     }
 }

References EState::es_range_table_size, EState::es_relations, i, NoLock, and table_close().

Referenced by CopyFrom(), and ExecEndPlan().

◆ ExecCloseResultRelations()

void ExecCloseResultRelations ( EState * estate )

Definition at line 1541 of file execMain.c.

 {
     ListCell   *l;
  
     /*
      * close indexes of result relation(s) if any.  (Rels themselves are
      * closed in ExecCloseRangeTableRelations())
      *
      * In addition, close the stub RTs that may be in each resultrel's
      * ri_ancestorResultRels.
      */
     foreach(l, estate->es_opened_result_relations)
     {
         ResultRelInfo *resultRelInfo = lfirst(l);
         ListCell   *lc;
  
         ExecCloseIndices(resultRelInfo);
         foreach(lc, resultRelInfo->ri_ancestorResultRels)
         {
             ResultRelInfo *rInfo = lfirst(lc);
  
             /*
              * Ancestors with RTI > 0 (should only be the root ancestor) are
              * closed by ExecCloseRangeTableRelations.
              */
             if (rInfo->ri_RangeTableIndex > 0)
                 continue;
  
             table_close(rInfo->ri_RelationDesc, NoLock);
         }
     }
  
     /* Close any relations that have been opened by ExecGetTriggerResultRel(). */
     foreach(l, estate->es_trig_target_relations)
     {
         ResultRelInfo *resultRelInfo = (ResultRelInfo *) lfirst(l);
  
         /*
          * Assert this is a "dummy" ResultRelInfo, see above.  Otherwise we
          * might be issuing a duplicate close against a Relation opened by
          * ExecGetRangeTableRelation.
          */
         Assert(resultRelInfo->ri_RangeTableIndex == 0);
  
         /*
          * Since ExecGetTriggerResultRel doesn't call ExecOpenIndices for
          * these rels, we needn't call ExecCloseIndices either.
          */
         Assert(resultRelInfo->ri_NumIndices == 0);
  
         table_close(resultRelInfo->ri_RelationDesc, NoLock);
     }
 }

References Assert(), EState::es_opened_result_relations, EState::es_trig_target_relations, ExecCloseIndices(), lfirst, NoLock, ResultRelInfo::ri_ancestorResultRels, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RelationDesc, and table_close().

Referenced by afterTriggerInvokeEvents(), CopyFrom(), EvalPlanQualEnd(), and ExecEndPlan().

◆ ExecConditionalAssignProjectionInfo()

void ExecConditionalAssignProjectionInfo	(	PlanState *	planstate,
		TupleDesc	inputDesc,
		int	varno
	)

Definition at line 563 of file execUtils.c.

 {
     if (tlist_matches_tupdesc(planstate,
                               planstate->plan->targetlist,
                               varno,
                               inputDesc))
     {
         planstate->ps_ProjInfo = NULL;
         planstate->resultopsset = planstate->scanopsset;
         planstate->resultopsfixed = planstate->scanopsfixed;
         planstate->resultops = planstate->scanops;
     }
     else
     {
         if (!planstate->ps_ResultTupleSlot)
         {
             ExecInitResultSlot(planstate, &TTSOpsVirtual);
             planstate->resultops = &TTSOpsVirtual;
             planstate->resultopsfixed = true;
             planstate->resultopsset = true;
         }
         ExecAssignProjectionInfo(planstate, inputDesc);
     }
 }

References ExecAssignProjectionInfo(), ExecInitResultSlot(), PlanState::plan, PlanState::ps_ProjInfo, PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, PlanState::scanops, PlanState::scanopsfixed, PlanState::scanopsset, Plan::targetlist, tlist_matches_tupdesc(), and TTSOpsVirtual.

Referenced by ExecAssignScanProjectionInfo(), ExecAssignScanProjectionInfoWithVarno(), ExecInitGather(), and ExecInitGatherMerge().

◆ ExecConstraints()

void ExecConstraints	(	ResultRelInfo *	resultRelInfo,
		TupleTableSlot *	slot,
		EState *	estate
	)

Definition at line 1940 of file execMain.c.

 {
     Relation    rel = resultRelInfo->ri_RelationDesc;
     TupleDesc   tupdesc = RelationGetDescr(rel);
     TupleConstr *constr = tupdesc->constr;
     Bitmapset  *modifiedCols;
  
     Assert(constr);             /* we should not be called otherwise */
  
     if (constr->has_not_null)
     {
         int         natts = tupdesc->natts;
         int         attrChk;
  
         for (attrChk = 1; attrChk <= natts; attrChk++)
         {
             Form_pg_attribute att = TupleDescAttr(tupdesc, attrChk - 1);
  
             if (att->attnotnull && slot_attisnull(slot, attrChk))
             {
                 char       *val_desc;
                 Relation    orig_rel = rel;
                 TupleDesc   orig_tupdesc = RelationGetDescr(rel);
  
                 /*
                  * If the tuple has been routed, it's been converted to the
                  * partition's rowtype, which might differ from the root
                  * table's.  We must convert it back to the root table's
                  * rowtype so that val_desc shown error message matches the
                  * input tuple.
                  */
                 if (resultRelInfo->ri_RootResultRelInfo)
                 {
                     ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
                     AttrMap    *map;
  
                     tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
                     /* a reverse map */
                     map = build_attrmap_by_name_if_req(orig_tupdesc,
                                                        tupdesc,
                                                        false);
  
                     /*
                      * Partition-specific slot's tupdesc can't be changed, so
                      * allocate a new one.
                      */
                     if (map != NULL)
                         slot = execute_attr_map_slot(map, slot,
                                                      MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
                     modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
                                              ExecGetUpdatedCols(rootrel, estate));
                     rel = rootrel->ri_RelationDesc;
                 }
                 else
                     modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
                                              ExecGetUpdatedCols(resultRelInfo, estate));
                 val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
                                                          slot,
                                                          tupdesc,
                                                          modifiedCols,
                                                          64);
  
                 ereport(ERROR,
                         (errcode(ERRCODE_NOT_NULL_VIOLATION),
                          errmsg("null value in column \"%s\" of relation \"%s\" violates not-null constraint",
                                 NameStr(att->attname),
                                 RelationGetRelationName(orig_rel)),
                          val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
                          errtablecol(orig_rel, attrChk)));
             }
         }
     }
  
     if (rel->rd_rel->relchecks > 0)
     {
         const char *failed;
  
         if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
         {
             char       *val_desc;
             Relation    orig_rel = rel;
  
             /* See the comment above. */
             if (resultRelInfo->ri_RootResultRelInfo)
             {
                 ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
                 TupleDesc   old_tupdesc = RelationGetDescr(rel);
                 AttrMap    *map;
  
                 tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
                 /* a reverse map */
                 map = build_attrmap_by_name_if_req(old_tupdesc,
                                                    tupdesc,
                                                    false);
  
                 /*
                  * Partition-specific slot's tupdesc can't be changed, so
                  * allocate a new one.
                  */
                 if (map != NULL)
                     slot = execute_attr_map_slot(map, slot,
                                                  MakeTupleTableSlot(tupdesc, &TTSOpsVirtual));
                 modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
                                          ExecGetUpdatedCols(rootrel, estate));
                 rel = rootrel->ri_RelationDesc;
             }
             else
                 modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
                                          ExecGetUpdatedCols(resultRelInfo, estate));
             val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
                                                      slot,
                                                      tupdesc,
                                                      modifiedCols,
                                                      64);
             ereport(ERROR,
                     (errcode(ERRCODE_CHECK_VIOLATION),
                      errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
                             RelationGetRelationName(orig_rel), failed),
                      val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
                      errtableconstraint(orig_rel, failed)));
         }
     }
 }

References Assert(), bms_union(), build_attrmap_by_name_if_req(), TupleDescData::constr, ereport, errcode(), errdetail(), errmsg(), ERROR, errtablecol(), errtableconstraint(), ExecBuildSlotValueDescription(), ExecGetInsertedCols(), ExecGetUpdatedCols(), ExecRelCheck(), execute_attr_map_slot(), TupleConstr::has_not_null, MakeTupleTableSlot(), NameStr, TupleDescData::natts, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, slot_attisnull(), TTSOpsVirtual, and TupleDescAttr.

Referenced by CopyFrom(), ExecInsert(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), and ExecUpdateAct().

◆ ExecCreateScanSlotFromOuterPlan()

void ExecCreateScanSlotFromOuterPlan	(	EState *	estate,
		ScanState *	scanstate,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 664 of file execUtils.c.

 {
     PlanState  *outerPlan;
     TupleDesc   tupDesc;
  
     outerPlan = outerPlanState(scanstate);
     tupDesc = ExecGetResultType(outerPlan);
  
     ExecInitScanTupleSlot(estate, scanstate, tupDesc, tts_ops);
 }

References ExecGetResultType(), ExecInitScanTupleSlot(), outerPlan, and outerPlanState.

Referenced by ExecInitAgg(), ExecInitGroup(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitMemoize(), ExecInitSort(), and ExecInitWindowAgg().

◆ execCurrentOf()

bool execCurrentOf	(	CurrentOfExpr *	cexpr,
		ExprContext *	econtext,
		Oid	table_oid,
		ItemPointer	current_tid
	)

Definition at line 44 of file execCurrent.c.

 {
     char       *cursor_name;
     char       *table_name;
     Portal      portal;
     QueryDesc  *queryDesc;
  
     /* Get the cursor name --- may have to look up a parameter reference */
     if (cexpr->cursor_name)
         cursor_name = cexpr->cursor_name;
     else
         cursor_name = fetch_cursor_param_value(econtext, cexpr->cursor_param);
  
     /* Fetch table name for possible use in error messages */
     table_name = get_rel_name(table_oid);
     if (table_name == NULL)
         elog(ERROR, "cache lookup failed for relation %u", table_oid);
  
     /* Find the cursor's portal */
     portal = GetPortalByName(cursor_name);
     if (!PortalIsValid(portal))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_CURSOR),
                  errmsg("cursor \"%s\" does not exist", cursor_name)));
  
     /*
      * We have to watch out for non-SELECT queries as well as held cursors,
      * both of which may have null queryDesc.
      */
     if (portal->strategy != PORTAL_ONE_SELECT)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_CURSOR_STATE),
                  errmsg("cursor \"%s\" is not a SELECT query",
                         cursor_name)));
     queryDesc = portal->queryDesc;
     if (queryDesc == NULL || queryDesc->estate == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_CURSOR_STATE),
                  errmsg("cursor \"%s\" is held from a previous transaction",
                         cursor_name)));
  
     /*
      * We have two different strategies depending on whether the cursor uses
      * FOR UPDATE/SHARE or not.  The reason for supporting both is that the
      * FOR UPDATE code is able to identify a target table in many cases where
      * the other code can't, while the non-FOR-UPDATE case allows use of WHERE
      * CURRENT OF with an insensitive cursor.
      */
     if (queryDesc->estate->es_rowmarks)
     {
         ExecRowMark *erm;
         Index       i;
  
         /*
          * Here, the query must have exactly one FOR UPDATE/SHARE reference to
          * the target table, and we dig the ctid info out of that.
          */
         erm = NULL;
         for (i = 0; i < queryDesc->estate->es_range_table_size; i++)
         {
             ExecRowMark *thiserm = queryDesc->estate->es_rowmarks[i];
  
             if (thiserm == NULL ||
                 !RowMarkRequiresRowShareLock(thiserm->markType))
                 continue;       /* ignore non-FOR UPDATE/SHARE items */
  
             if (thiserm->relid == table_oid)
             {
                 if (erm)
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_CURSOR_STATE),
                              errmsg("cursor \"%s\" has multiple FOR UPDATE/SHARE references to table \"%s\"",
                                     cursor_name, table_name)));
                 erm = thiserm;
             }
         }
  
         if (erm == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_CURSOR_STATE),
                      errmsg("cursor \"%s\" does not have a FOR UPDATE/SHARE reference to table \"%s\"",
                             cursor_name, table_name)));
  
         /*
          * The cursor must have a current result row: per the SQL spec, it's
          * an error if not.
          */
         if (portal->atStart || portal->atEnd)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_CURSOR_STATE),
                      errmsg("cursor \"%s\" is not positioned on a row",
                             cursor_name)));
  
         /* Return the currently scanned TID, if there is one */
         if (ItemPointerIsValid(&(erm->curCtid)))
         {
             *current_tid = erm->curCtid;
             return true;
         }
  
         /*
          * This table didn't produce the cursor's current row; some other
          * inheritance child of the same parent must have.  Signal caller to
          * do nothing on this table.
          */
         return false;
     }
     else
     {
         /*
          * Without FOR UPDATE, we dig through the cursor's plan to find the
          * scan node.  Fail if it's not there or buried underneath
          * aggregation.
          */
         ScanState  *scanstate;
         bool        pending_rescan = false;
  
         scanstate = search_plan_tree(queryDesc->planstate, table_oid,
                                      &pending_rescan);
         if (!scanstate)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_CURSOR_STATE),
                      errmsg("cursor \"%s\" is not a simply updatable scan of table \"%s\"",
                             cursor_name, table_name)));
  
         /*
          * The cursor must have a current result row: per the SQL spec, it's
          * an error if not.  We test this at the top level, rather than at the
          * scan node level, because in inheritance cases any one table scan
          * could easily not be on a row. We want to return false, not raise
          * error, if the passed-in table OID is for one of the inactive scans.
          */
         if (portal->atStart || portal->atEnd)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_CURSOR_STATE),
                      errmsg("cursor \"%s\" is not positioned on a row",
                             cursor_name)));
  
         /*
          * Now OK to return false if we found an inactive scan.  It is
          * inactive either if it's not positioned on a row, or there's a
          * rescan pending for it.
          */
         if (TupIsNull(scanstate->ss_ScanTupleSlot) || pending_rescan)
             return false;
  
         /*
          * Extract TID of the scan's current row.  The mechanism for this is
          * in principle scan-type-dependent, but for most scan types, we can
          * just dig the TID out of the physical scan tuple.
          */
         if (IsA(scanstate, IndexOnlyScanState))
         {
             /*
              * For IndexOnlyScan, the tuple stored in ss_ScanTupleSlot may be
              * a virtual tuple that does not have the ctid column, so we have
              * to get the TID from xs_ctup.t_self.
              */
             IndexScanDesc scan = ((IndexOnlyScanState *) scanstate)->ioss_ScanDesc;
  
             *current_tid = scan->xs_heaptid;
         }
         else
         {
             /*
              * Default case: try to fetch TID from the scan node's current
              * tuple.  As an extra cross-check, verify tableoid in the current
              * tuple.  If the scan hasn't provided a physical tuple, we have
              * to fail.
              */
             Datum       ldatum;
             bool        lisnull;
             ItemPointer tuple_tid;
  
 #ifdef USE_ASSERT_CHECKING
             ldatum = slot_getsysattr(scanstate->ss_ScanTupleSlot,
                                      TableOidAttributeNumber,
                                      &lisnull);
             if (lisnull)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_CURSOR_STATE),
                          errmsg("cursor \"%s\" is not a simply updatable scan of table \"%s\"",
                                 cursor_name, table_name)));
             Assert(DatumGetObjectId(ldatum) == table_oid);
 #endif
  
             ldatum = slot_getsysattr(scanstate->ss_ScanTupleSlot,
                                      SelfItemPointerAttributeNumber,
                                      &lisnull);
             if (lisnull)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_CURSOR_STATE),
                          errmsg("cursor \"%s\" is not a simply updatable scan of table \"%s\"",
                                 cursor_name, table_name)));
             tuple_tid = (ItemPointer) DatumGetPointer(ldatum);
  
             *current_tid = *tuple_tid;
         }
  
         Assert(ItemPointerIsValid(current_tid));
  
         return true;
     }
 }

References Assert(), PortalData::atEnd, PortalData::atStart, ExecRowMark::curCtid, CurrentOfExpr::cursor_name, CurrentOfExpr::cursor_param, DatumGetObjectId(), DatumGetPointer(), elog(), ereport, errcode(), errmsg(), ERROR, EState::es_range_table_size, EState::es_rowmarks, QueryDesc::estate, fetch_cursor_param_value(), get_rel_name(), GetPortalByName(), i, IsA, ItemPointerIsValid(), ExecRowMark::markType, QueryDesc::planstate, PORTAL_ONE_SELECT, PortalIsValid, PortalData::queryDesc, ExecRowMark::relid, RowMarkRequiresRowShareLock, search_plan_tree(), SelfItemPointerAttributeNumber, slot_getsysattr(), ScanState::ss_ScanTupleSlot, PortalData::strategy, TableOidAttributeNumber, TupIsNull, and IndexScanDescData::xs_heaptid.

Referenced by TidListEval().

◆ ExecEndNode()

void ExecEndNode ( PlanState * node )

Definition at line 557 of file execProcnode.c.

 {
     /*
      * do nothing when we get to the end of a leaf on tree.
      */
     if (node == NULL)
         return;
  
     /*
      * Make sure there's enough stack available. Need to check here, in
      * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
      * guaranteed that ExecProcNode() is reached for all nodes.
      */
     check_stack_depth();
  
     if (node->chgParam != NULL)
     {
         bms_free(node->chgParam);
         node->chgParam = NULL;
     }
  
     switch (nodeTag(node))
     {
             /*
              * control nodes
              */
         case T_ResultState:
             ExecEndResult((ResultState *) node);
             break;
  
         case T_ProjectSetState:
             ExecEndProjectSet((ProjectSetState *) node);
             break;
  
         case T_ModifyTableState:
             ExecEndModifyTable((ModifyTableState *) node);
             break;
  
         case T_AppendState:
             ExecEndAppend((AppendState *) node);
             break;
  
         case T_MergeAppendState:
             ExecEndMergeAppend((MergeAppendState *) node);
             break;
  
         case T_RecursiveUnionState:
             ExecEndRecursiveUnion((RecursiveUnionState *) node);
             break;
  
         case T_BitmapAndState:
             ExecEndBitmapAnd((BitmapAndState *) node);
             break;
  
         case T_BitmapOrState:
             ExecEndBitmapOr((BitmapOrState *) node);
             break;
  
             /*
              * scan nodes
              */
         case T_SeqScanState:
             ExecEndSeqScan((SeqScanState *) node);
             break;
  
         case T_SampleScanState:
             ExecEndSampleScan((SampleScanState *) node);
             break;
  
         case T_GatherState:
             ExecEndGather((GatherState *) node);
             break;
  
         case T_GatherMergeState:
             ExecEndGatherMerge((GatherMergeState *) node);
             break;
  
         case T_IndexScanState:
             ExecEndIndexScan((IndexScanState *) node);
             break;
  
         case T_IndexOnlyScanState:
             ExecEndIndexOnlyScan((IndexOnlyScanState *) node);
             break;
  
         case T_BitmapIndexScanState:
             ExecEndBitmapIndexScan((BitmapIndexScanState *) node);
             break;
  
         case T_BitmapHeapScanState:
             ExecEndBitmapHeapScan((BitmapHeapScanState *) node);
             break;
  
         case T_TidScanState:
             ExecEndTidScan((TidScanState *) node);
             break;
  
         case T_TidRangeScanState:
             ExecEndTidRangeScan((TidRangeScanState *) node);
             break;
  
         case T_SubqueryScanState:
             ExecEndSubqueryScan((SubqueryScanState *) node);
             break;
  
         case T_FunctionScanState:
             ExecEndFunctionScan((FunctionScanState *) node);
             break;
  
         case T_TableFuncScanState:
             ExecEndTableFuncScan((TableFuncScanState *) node);
             break;
  
         case T_CteScanState:
             ExecEndCteScan((CteScanState *) node);
             break;
  
         case T_ForeignScanState:
             ExecEndForeignScan((ForeignScanState *) node);
             break;
  
         case T_CustomScanState:
             ExecEndCustomScan((CustomScanState *) node);
             break;
  
             /*
              * join nodes
              */
         case T_NestLoopState:
             ExecEndNestLoop((NestLoopState *) node);
             break;
  
         case T_MergeJoinState:
             ExecEndMergeJoin((MergeJoinState *) node);
             break;
  
         case T_HashJoinState:
             ExecEndHashJoin((HashJoinState *) node);
             break;
  
             /*
              * materialization nodes
              */
         case T_MaterialState:
             ExecEndMaterial((MaterialState *) node);
             break;
  
         case T_SortState:
             ExecEndSort((SortState *) node);
             break;
  
         case T_IncrementalSortState:
             ExecEndIncrementalSort((IncrementalSortState *) node);
             break;
  
         case T_MemoizeState:
             ExecEndMemoize((MemoizeState *) node);
             break;
  
         case T_GroupState:
             ExecEndGroup((GroupState *) node);
             break;
  
         case T_AggState:
             ExecEndAgg((AggState *) node);
             break;
  
         case T_WindowAggState:
             ExecEndWindowAgg((WindowAggState *) node);
             break;
  
         case T_UniqueState:
             ExecEndUnique((UniqueState *) node);
             break;
  
         case T_HashState:
             ExecEndHash((HashState *) node);
             break;
  
         case T_SetOpState:
             ExecEndSetOp((SetOpState *) node);
             break;
  
         case T_LockRowsState:
             ExecEndLockRows((LockRowsState *) node);
             break;
  
         case T_LimitState:
             ExecEndLimit((LimitState *) node);
             break;
  
             /* No clean up actions for these nodes. */
         case T_ValuesScanState:
         case T_NamedTuplestoreScanState:
         case T_WorkTableScanState:
             break;
  
         default:
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
             break;
     }
 }

References bms_free(), check_stack_depth(), PlanState::chgParam, elog(), ERROR, ExecEndAgg(), ExecEndAppend(), ExecEndBitmapAnd(), ExecEndBitmapHeapScan(), ExecEndBitmapIndexScan(), ExecEndBitmapOr(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndIncrementalSort(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMemoize(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidRangeScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndWindowAgg(), and nodeTag.

Referenced by EvalPlanQualEnd(), ExecEndAgg(), ExecEndAppend(), ExecEndBitmapAnd(), ExecEndBitmapHeapScan(), ExecEndBitmapOr(), ExecEndForeignScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndIncrementalSort(), ExecEndLimit(), ExecEndLockRows(), ExecEndMaterial(), ExecEndMemoize(), ExecEndMergeAppend(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNestLoop(), ExecEndPlan(), ExecEndProjectSet(), ExecEndRecursiveUnion(), ExecEndResult(), ExecEndSetOp(), ExecEndSort(), ExecEndSubqueryScan(), ExecEndUnique(), and ExecEndWindowAgg().

◆ ExecEvalExpr()

static Datum ExecEvalExpr	(	ExprState *	state,
		ExprContext *	econtext,
		bool *	isNull
	)

inlinestatic

Definition at line 332 of file executor.h.

 {
     return state->evalfunc(state, econtext, isNull);
 }

Referenced by advance_windowaggregate(), advance_windowaggregate_base(), array_map(), ATRewriteTable(), do_cast_value(), EvalOrderByExpressions(), exec_eval_simple_expr(), ExecComputeStoredGenerated(), ExecEvalFuncArgs(), ExecHashGetHashValue(), ExecIndexEvalArrayKeys(), ExecIndexEvalRuntimeKeys(), ExecMakeTableFunctionResult(), ExecProjectSRF(), finalize_aggregate(), make_build_data(), MJEvalInnerValues(), MJEvalOuterValues(), NextCopyFrom(), prepare_probe_slot(), process_query_params(), slot_fill_defaults(), StoreAttrDefault(), tfuncFetchRows(), tfuncInitialize(), tfuncLoadRows(), ValuesNext(), WinGetFuncArgCurrent(), WinGetFuncArgInFrame(), and WinGetFuncArgInPartition().

◆ ExecEvalExprSwitchContext()

static Datum ExecEvalExprSwitchContext	(	ExprState *	state,
		ExprContext *	econtext,
		bool *	isNull
	)

inlinestatic

Definition at line 347 of file executor.h.

 {
     Datum       retDatum;
     MemoryContext oldContext;
  
     oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
     retDatum = state->evalfunc(state, econtext, isNull);
     MemoryContextSwitchTo(oldContext);
     return retDatum;
 }

References ExprContext::ecxt_per_tuple_memory, and MemoryContextSwitchTo().

Referenced by advance_aggregates(), compute_expr_stats(), evaluate_expr(), EvaluateParams(), ExecCheck(), ExecProject(), ExecQual(), ExecScanSubPlan(), ExecuteCallStmt(), ExecWindowAgg(), FormIndexDatum(), FormPartitionKeyDatum(), get_qual_for_range(), operator_predicate_proof(), partkey_datum_from_expr(), pgoutput_row_filter_exec_expr(), recompute_limits(), tablesample_init(), TidListEval(), TidRangeEval(), and validateDomainConstraint().

◆ ExecFilterJunk()

TupleTableSlot* ExecFilterJunk	(	JunkFilter *	junkfilter,
		TupleTableSlot *	slot
	)

Definition at line 247 of file execJunk.c.

 {
     TupleTableSlot *resultSlot;
     AttrNumber *cleanMap;
     TupleDesc   cleanTupType;
     int         cleanLength;
     int         i;
     Datum      *values;
     bool       *isnull;
     Datum      *old_values;
     bool       *old_isnull;
  
     /*
      * Extract all the values of the old tuple.
      */
     slot_getallattrs(slot);
     old_values = slot->tts_values;
     old_isnull = slot->tts_isnull;
  
     /*
      * get info from the junk filter
      */
     cleanTupType = junkfilter->jf_cleanTupType;
     cleanLength = cleanTupType->natts;
     cleanMap = junkfilter->jf_cleanMap;
     resultSlot = junkfilter->jf_resultSlot;
  
     /*
      * Prepare to build a virtual result tuple.
      */
     ExecClearTuple(resultSlot);
     values = resultSlot->tts_values;
     isnull = resultSlot->tts_isnull;
  
     /*
      * Transpose data into proper fields of the new tuple.
      */
     for (i = 0; i < cleanLength; i++)
     {
         int         j = cleanMap[i];
  
         if (j == 0)
         {
             values[i] = (Datum) 0;
             isnull[i] = true;
         }
         else
         {
             values[i] = old_values[j - 1];
             isnull[i] = old_isnull[j - 1];
         }
     }
  
     /*
      * And return the virtual tuple.
      */
     return ExecStoreVirtualTuple(resultSlot);
 }

References ExecClearTuple(), ExecStoreVirtualTuple(), i, j, JunkFilter::jf_cleanMap, JunkFilter::jf_cleanTupType, JunkFilter::jf_resultSlot, TupleDescData::natts, slot_getallattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, and values.

Referenced by ExecEvalWholeRowVar(), ExecutePlan(), and sqlfunction_receive().

◆ ExecFindJunkAttribute()

AttrNumber ExecFindJunkAttribute	(	JunkFilter *	junkfilter,
		const char *	attrName
	)

Definition at line 210 of file execJunk.c.

 {
     return ExecFindJunkAttributeInTlist(junkfilter->jf_targetList, attrName);
 }

References ExecFindJunkAttributeInTlist(), and JunkFilter::jf_targetList.

◆ ExecFindJunkAttributeInTlist()

AttrNumber ExecFindJunkAttributeInTlist	(	List *	targetlist,
		const char *	attrName
	)

Definition at line 222 of file execJunk.c.

 {
     ListCell   *t;
  
     foreach(t, targetlist)
     {
         TargetEntry *tle = lfirst(t);
  
         if (tle->resjunk && tle->resname &&
             (strcmp(tle->resname, attrName) == 0))
         {
             /* We found it ! */
             return tle->resno;
         }
     }
  
     return InvalidAttrNumber;
 }

References InvalidAttrNumber, lfirst, and TargetEntry::resno.

Referenced by create_foreign_modify(), ExecBuildAuxRowMark(), ExecFindJunkAttribute(), and ExecInitModifyTable().

◆ ExecFindRowMark()

ExecRowMark* ExecFindRowMark	(	EState *	estate,
		Index	rti,
		bool	missing_ok
	)

Definition at line 2401 of file execMain.c.

 {
     if (rti > 0 && rti <= estate->es_range_table_size &&
         estate->es_rowmarks != NULL)
     {
         ExecRowMark *erm = estate->es_rowmarks[rti - 1];
  
         if (erm)
             return erm;
     }
     if (!missing_ok)
         elog(ERROR, "failed to find ExecRowMark for rangetable index %u", rti);
     return NULL;
 }

References elog(), ERROR, and EState::es_rowmarks.

Referenced by ExecInitLockRows(), and ExecInitModifyTable().

◆ ExecGetAllUpdatedCols()

Bitmapset* ExecGetAllUpdatedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1329 of file execUtils.c.

 {
     Bitmapset  *ret;
     MemoryContext oldcxt;
  
     oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
     ret = bms_union(ExecGetUpdatedCols(relinfo, estate),
                     ExecGetExtraUpdatedCols(relinfo, estate));
  
     MemoryContextSwitchTo(oldcxt);
  
     return ret;
 }

References bms_union(), ExecGetExtraUpdatedCols(), ExecGetUpdatedCols(), GetPerTupleMemoryContext, and MemoryContextSwitchTo().

Referenced by ExecARUpdateTriggers(), ExecASUpdateTriggers(), ExecBRUpdateTriggers(), ExecBSUpdateTriggers(), and ExecUpdateLockMode().

◆ ExecGetAncestorResultRels()

List* ExecGetAncestorResultRels	(	EState *	estate,
		ResultRelInfo *	resultRelInfo
	)

Definition at line 1396 of file execMain.c.

 {
     ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
     Relation    partRel = resultRelInfo->ri_RelationDesc;
     Oid         rootRelOid;
  
     if (!partRel->rd_rel->relispartition)
         elog(ERROR, "cannot find ancestors of a non-partition result relation");
     Assert(rootRelInfo != NULL);
     rootRelOid = RelationGetRelid(rootRelInfo->ri_RelationDesc);
     if (resultRelInfo->ri_ancestorResultRels == NIL)
     {
         ListCell   *lc;
         List       *oids = get_partition_ancestors(RelationGetRelid(partRel));
         List       *ancResultRels = NIL;
  
         foreach(lc, oids)
         {
             Oid         ancOid = lfirst_oid(lc);
             Relation    ancRel;
             ResultRelInfo *rInfo;
  
             /*
              * Ignore the root ancestor here, and use ri_RootResultRelInfo
              * (below) for it instead.  Also, we stop climbing up the
              * hierarchy when we find the table that was mentioned in the
              * query.
              */
             if (ancOid == rootRelOid)
                 break;
  
             /*
              * All ancestors up to the root target relation must have been
              * locked by the planner or AcquireExecutorLocks().
              */
             ancRel = table_open(ancOid, NoLock);
             rInfo = makeNode(ResultRelInfo);
  
             /* dummy rangetable index */
             InitResultRelInfo(rInfo, ancRel, 0, NULL,
                               estate->es_instrument);
             ancResultRels = lappend(ancResultRels, rInfo);
         }
         ancResultRels = lappend(ancResultRels, rootRelInfo);
         resultRelInfo->ri_ancestorResultRels = ancResultRels;
     }
  
     /* We must have found some ancestor */
     Assert(resultRelInfo->ri_ancestorResultRels != NIL);
  
     return resultRelInfo->ri_ancestorResultRels;
 }

References Assert(), elog(), ERROR, EState::es_instrument, get_partition_ancestors(), InitResultRelInfo(), lappend(), lfirst_oid, makeNode, NIL, NoLock, RelationData::rd_rel, RelationGetRelid, ResultRelInfo::ri_ancestorResultRels, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, and table_open().

Referenced by ExecCrossPartitionUpdateForeignKey().

◆ ExecGetChildToRootMap()

TupleConversionMap* ExecGetChildToRootMap ( ResultRelInfo * resultRelInfo )

Definition at line 1211 of file execUtils.c.

 {
     /* If we didn't already do so, compute the map for this child. */
     if (!resultRelInfo->ri_ChildToRootMapValid)
     {
         ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
  
         if (rootRelInfo)
             resultRelInfo->ri_ChildToRootMap =
                 convert_tuples_by_name(RelationGetDescr(resultRelInfo->ri_RelationDesc),
                                        RelationGetDescr(rootRelInfo->ri_RelationDesc));
         else                    /* this isn't a child result rel */
             resultRelInfo->ri_ChildToRootMap = NULL;
  
         resultRelInfo->ri_ChildToRootMapValid = true;
     }
  
     return resultRelInfo->ri_ChildToRootMap;
 }

References convert_tuples_by_name(), RelationGetDescr, ResultRelInfo::ri_ChildToRootMap, ResultRelInfo::ri_ChildToRootMapValid, ResultRelInfo::ri_RelationDesc, and ResultRelInfo::ri_RootResultRelInfo.

Referenced by adjust_partition_colnos(), AfterTriggerExecute(), AfterTriggerSaveEvent(), ExecCrossPartitionUpdate(), and TransitionTableAddTuple().

◆ ExecGetExtraUpdatedCols()

Bitmapset* ExecGetExtraUpdatedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1314 of file execUtils.c.

 {
     /* Compute the info if we didn't already */
     if (relinfo->ri_GeneratedExprsU == NULL)
         ExecInitStoredGenerated(relinfo, estate, CMD_UPDATE);
     return relinfo->ri_extraUpdatedCols;
 }

References CMD_UPDATE, ExecInitStoredGenerated(), ResultRelInfo::ri_extraUpdatedCols, and ResultRelInfo::ri_GeneratedExprsU.

Referenced by ExecGetAllUpdatedCols(), and index_unchanged_by_update().

◆ ExecGetInsertedCols()

Bitmapset* ExecGetInsertedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1272 of file execUtils.c.

 {
     RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
  
     if (perminfo == NULL)
         return NULL;
  
     /* Map the columns to child's attribute numbers if needed. */
     if (relinfo->ri_RootResultRelInfo)
     {
         TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
  
         if (map)
             return execute_attr_map_cols(map->attrMap, perminfo->insertedCols);
     }
  
     return perminfo->insertedCols;
 }

References TupleConversionMap::attrMap, ExecGetRootToChildMap(), execute_attr_map_cols(), GetResultRTEPermissionInfo(), RTEPermissionInfo::insertedCols, and ResultRelInfo::ri_RootResultRelInfo.

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

◆ ExecGetJunkAttribute()

static Datum ExecGetJunkAttribute	(	TupleTableSlot *	slot,
		AttrNumber	attno,
		bool *	isNull
	)

inlinestatic

Definition at line 190 of file executor.h.

 {
     Assert(attno > 0);
     return slot_getattr(slot, attno, isNull);
 }

References Assert(), and slot_getattr().

Referenced by EvalPlanQualFetchRowMark(), ExecLockRows(), ExecMergeMatched(), ExecModifyTable(), and execute_foreign_modify().

◆ ExecGetRangeTableRelation()

Relation ExecGetRangeTableRelation	(	EState *	estate,
		Index	rti
	)

Definition at line 767 of file execUtils.c.

 {
     Relation    rel;
  
     Assert(rti > 0 && rti <= estate->es_range_table_size);
  
     rel = estate->es_relations[rti - 1];
     if (rel == NULL)
     {
         /* First time through, so open the relation */
         RangeTblEntry *rte = exec_rt_fetch(rti, estate);
  
         Assert(rte->rtekind == RTE_RELATION);
  
         if (!IsParallelWorker())
         {
             /*
              * In a normal query, we should already have the appropriate lock,
              * but verify that through an Assert.  Since there's already an
              * Assert inside table_open that insists on holding some lock, it
              * seems sufficient to check this only when rellockmode is higher
              * than the minimum.
              */
             rel = table_open(rte->relid, NoLock);
             Assert(rte->rellockmode == AccessShareLock ||
                    CheckRelationLockedByMe(rel, rte->rellockmode, false));
         }
         else
         {
             /*
              * If we are a parallel worker, we need to obtain our own local
              * lock on the relation.  This ensures sane behavior in case the
              * parent process exits before we do.
              */
             rel = table_open(rte->relid, rte->rellockmode);
         }
  
         estate->es_relations[rti - 1] = rel;
     }
  
     return rel;
 }

References AccessShareLock, Assert(), CheckRelationLockedByMe(), EState::es_relations, exec_rt_fetch(), IsParallelWorker, NoLock, RangeTblEntry::relid, RangeTblEntry::rellockmode, RTE_RELATION, RangeTblEntry::rtekind, and table_open().

Referenced by CreatePartitionPruneState(), ExecInitResultRelation(), ExecOpenScanRelation(), and InitPlan().

◆ ExecGetResultRelCheckAsUser()

Oid ExecGetResultRelCheckAsUser	(	ResultRelInfo *	relInfo,
		EState *	estate
	)

Definition at line 1400 of file execUtils.c.

 {
     RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relInfo, estate);
  
     /* XXX - maybe ok to return GetUserId() in this case? */
     if (perminfo == NULL)
         elog(ERROR, "no RTEPermissionInfo found for result relation with OID %u",
              RelationGetRelid(relInfo->ri_RelationDesc));
  
     return perminfo->checkAsUser ? perminfo->checkAsUser : GetUserId();
 }

References RTEPermissionInfo::checkAsUser, elog(), ERROR, GetResultRTEPermissionInfo(), GetUserId(), RelationGetRelid, and ResultRelInfo::ri_RelationDesc.

Referenced by create_foreign_modify().

◆ ExecGetResultSlotOps()

const TupleTableSlotOps* ExecGetResultSlotOps	(	PlanState *	planstate,
		bool *	isfixed
	)

Definition at line 507 of file execUtils.c.

 {
     if (planstate->resultopsset && planstate->resultops)
     {
         if (isfixed)
             *isfixed = planstate->resultopsfixed;
         return planstate->resultops;
     }
  
     if (isfixed)
     {
         if (planstate->resultopsset)
             *isfixed = planstate->resultopsfixed;
         else if (planstate->ps_ResultTupleSlot)
             *isfixed = TTS_FIXED(planstate->ps_ResultTupleSlot);
         else
             *isfixed = false;
     }
  
     if (!planstate->ps_ResultTupleSlot)
         return &TTSOpsVirtual;
  
     return planstate->ps_ResultTupleSlot->tts_ops;
 }

References PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, TTS_FIXED, TupleTableSlot::tts_ops, and TTSOpsVirtual.

Referenced by ExecComputeSlotInfo(), ExecInitAgg(), ExecInitGroup(), ExecInitHashJoin(), ExecInitLimit(), ExecInitLockRows(), ExecInitMergeJoin(), and ExecInitSubqueryScan().

◆ ExecGetResultType()

TupleDesc ExecGetResultType ( PlanState * planstate )

Definition at line 498 of file execUtils.c.

 {
     return planstate->ps_ResultTupleDesc;
 }

References PlanState::ps_ResultTupleDesc.

Referenced by build_hash_table(), ExecComputeSlotInfo(), ExecCreateScanSlotFromOuterPlan(), ExecIncrementalSort(), ExecInitCteScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitLimit(), ExecInitMergeJoin(), ExecInitNestLoop(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecSort(), ExecWorkTableScan(), initialize_phase(), InitPlan(), and switchToPresortedPrefixMode().

◆ ExecGetReturningSlot()

TupleTableSlot* ExecGetReturningSlot	(	EState *	estate,
		ResultRelInfo *	relInfo
	)

Definition at line 1187 of file execUtils.c.

 {
     if (relInfo->ri_ReturningSlot == NULL)
     {
         Relation    rel = relInfo->ri_RelationDesc;
         MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
  
         relInfo->ri_ReturningSlot =
             ExecInitExtraTupleSlot(estate,
                                    RelationGetDescr(rel),
                                    table_slot_callbacks(rel));
  
         MemoryContextSwitchTo(oldcontext);
     }
  
     return relInfo->ri_ReturningSlot;
 }

References EState::es_query_cxt, ExecInitExtraTupleSlot(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_ReturningSlot, and table_slot_callbacks().

Referenced by apply_returning_filter(), ExecDelete(), and ExecInsert().

◆ ExecGetRootToChildMap()

TupleConversionMap* ExecGetRootToChildMap	(	ResultRelInfo *	resultRelInfo,
		EState *	estate
	)

Definition at line 1237 of file execUtils.c.

 {
     /* Mustn't get called for a non-child result relation. */
     Assert(resultRelInfo->ri_RootResultRelInfo);
  
     /* If we didn't already do so, compute the map for this child. */
     if (!resultRelInfo->ri_RootToChildMapValid)
     {
         ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
         TupleDesc   indesc = RelationGetDescr(rootRelInfo->ri_RelationDesc);
         TupleDesc   outdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
         Relation    childrel = resultRelInfo->ri_RelationDesc;
         AttrMap    *attrMap;
         MemoryContext oldcontext;
  
         /*
          * When this child table is not a partition (!relispartition), it may
          * have columns that are not present in the root table, which we ask
          * to ignore by passing true for missing_ok.
          */
         oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
         attrMap = build_attrmap_by_name_if_req(indesc, outdesc,
                                                !childrel->rd_rel->relispartition);
         if (attrMap)
             resultRelInfo->ri_RootToChildMap =
                 convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
         MemoryContextSwitchTo(oldcontext);
         resultRelInfo->ri_RootToChildMapValid = true;
     }
  
     return resultRelInfo->ri_RootToChildMap;
 }

References Assert(), build_attrmap_by_name_if_req(), convert_tuples_by_name_attrmap(), EState::es_query_cxt, MemoryContextSwitchTo(), RelationData::rd_rel, RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_RootToChildMap, and ResultRelInfo::ri_RootToChildMapValid.

Referenced by apply_handle_tuple_routing(), CopyFrom(), ExecFindPartition(), ExecGetInsertedCols(), ExecGetUpdatedCols(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), and ExecPrepareTupleRouting().

◆ ExecGetTriggerNewSlot()

TupleTableSlot* ExecGetTriggerNewSlot	(	EState *	estate,
		ResultRelInfo *	relInfo
	)

Definition at line 1165 of file execUtils.c.

 {
     if (relInfo->ri_TrigNewSlot == NULL)
     {
         Relation    rel = relInfo->ri_RelationDesc;
         MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
  
         relInfo->ri_TrigNewSlot =
             ExecInitExtraTupleSlot(estate,
                                    RelationGetDescr(rel),
                                    table_slot_callbacks(rel));
  
         MemoryContextSwitchTo(oldcontext);
     }
  
     return relInfo->ri_TrigNewSlot;
 }

References EState::es_query_cxt, ExecInitExtraTupleSlot(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigNewSlot, and table_slot_callbacks().

Referenced by AfterTriggerExecute(), and AfterTriggerSaveEvent().

◆ ExecGetTriggerOldSlot()

TupleTableSlot* ExecGetTriggerOldSlot	(	EState *	estate,
		ResultRelInfo *	relInfo
	)

Definition at line 1143 of file execUtils.c.

 {
     if (relInfo->ri_TrigOldSlot == NULL)
     {
         Relation    rel = relInfo->ri_RelationDesc;
         MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
  
         relInfo->ri_TrigOldSlot =
             ExecInitExtraTupleSlot(estate,
                                    RelationGetDescr(rel),
                                    table_slot_callbacks(rel));
  
         MemoryContextSwitchTo(oldcontext);
     }
  
     return relInfo->ri_TrigOldSlot;
 }

References EState::es_query_cxt, ExecInitExtraTupleSlot(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigOldSlot, and table_slot_callbacks().

Referenced by AfterTriggerExecute(), AfterTriggerSaveEvent(), ExecARDeleteTriggers(), ExecARUpdateTriggers(), ExecBRDeleteTriggers(), ExecBRUpdateTriggers(), ExecIRDeleteTriggers(), and ExecIRUpdateTriggers().

◆ ExecGetTriggerResultRel()

ResultRelInfo* ExecGetTriggerResultRel	(	EState *	estate,
		Oid	relid,
		ResultRelInfo *	rootRelInfo
	)

Definition at line 1320 of file execMain.c.

 {
     ResultRelInfo *rInfo;

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ do_text_output_oneline

◆ EvalPlanQualSetSlot

◆ EXEC_FLAG_BACKWARD

◆ EXEC_FLAG_EXPLAIN_GENERIC

◆ EXEC_FLAG_EXPLAIN_ONLY

◆ EXEC_FLAG_MARK

◆ EXEC_FLAG_REWIND

◆ EXEC_FLAG_SKIP_TRIGGERS

◆ EXEC_FLAG_WITH_NO_DATA

◆ GetPerTupleExprContext

◆ GetPerTupleMemoryContext

◆ ResetExprContext

◆ ResetPerTupleExprContext

Typedef Documentation

◆ ExecScanAccessMtd

◆ ExecScanRecheckMtd

◆ ExecutorCheckPerms_hook_type

◆ ExecutorEnd_hook_type

◆ ExecutorFinish_hook_type

◆ ExecutorRun_hook_type

◆ ExecutorStart_hook_type

◆ TupOutputState

Function Documentation

◆ begin_tup_output_tupdesc()

◆ BuildTupleHashTable()

◆ BuildTupleHashTableExt()

◆ check_exclusion_constraint()

◆ CheckCmdReplicaIdentity()

◆ CheckSubscriptionRelkind()

◆ CheckValidResultRel()

◆ CreateExecutorState()

◆ CreateExprContext()

◆ CreateStandaloneExprContext()

◆ CreateWorkExprContext()

◆ do_text_output_multiline()

◆ do_tup_output()

◆ end_tup_output()

◆ EvalPlanQual()

◆ EvalPlanQualBegin()

◆ EvalPlanQualEnd()

◆ EvalPlanQualFetchRowMark()

◆ EvalPlanQualInit()

◆ EvalPlanQualNext()

◆ EvalPlanQualSetPlan()

◆ EvalPlanQualSlot()

◆ exec_rt_fetch()

◆ ExecAssignExprContext()

◆ ExecAssignProjectionInfo()

◆ ExecAssignScanProjectionInfo()

◆ ExecAssignScanProjectionInfoWithVarno()

◆ ExecAssignScanType()

◆ ExecBuildAggTrans()

◆ ExecBuildAuxRowMark()

◆ ExecBuildGroupingEqual()

◆ ExecBuildParamSetEqual()

◆ ExecBuildProjectionInfo()

◆ ExecBuildUpdateProjection()

◆ ExecCheck()

◆ ExecCheckIndexConstraints()

◆ ExecCheckPermissions()

◆ ExecCleanTargetListLength()

◆ ExecCleanTypeFromTL()

◆ ExecCloseIndices()

◆ ExecCloseRangeTableRelations()

◆ ExecCloseResultRelations()

◆ ExecConditionalAssignProjectionInfo()

◆ ExecConstraints()

◆ ExecCreateScanSlotFromOuterPlan()

◆ execCurrentOf()

◆ ExecEndNode()

◆ ExecEvalExpr()

◆ ExecEvalExprSwitchContext()

◆ ExecFilterJunk()

◆ ExecFindJunkAttribute()