#include "executor/execdesc.h"
#include "fmgr.h"
#include "nodes/lockoptions.h"
#include "nodes/parsenodes.h"
#include "utils/memutils.h"
#include "utils/plancache.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 bool(*	ExecutorStart_hook_type) (QueryDesc *queryDesc, int eflags)

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

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, const TupleTableSlotOps inputOps, 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, ExprState *hashexpr)

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)

bool	ExecutorStart (QueryDesc *queryDesc, int eflags)

void	ExecutorStartCachedPlan (QueryDesc queryDesc, int eflags, CachedPlanSource plansource, int query_index)

bool	standard_ExecutorStart (QueryDesc *queryDesc, int eflags)

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

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

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, List mergeActions)

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)

char *	ExecBuildSlotValueDescription (Oid reloid, TupleTableSlot slot, TupleDesc tupdesc, Bitmapset modifiedCols, int maxfieldlen)

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 bool	ExecPlanStillValid (EState *estate)

static bool	ExecShouldLockRelations (EState *estate)

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 *	ExecBuildHash32FromAttrs (TupleDesc desc, const TupleTableSlotOps ops, FmgrInfo hashfunctions, Oid collations, int numCols, AttrNumber keyColIdx, PlanState *parent, uint32 init_value)

ExprState *	ExecBuildHash32Expr (TupleDesc desc, const TupleTableSlotOps ops, const Oid hashfunc_oids, const List collations, const List hash_exprs, const bool opstrict, PlanState parent, uint32 init_value, bool keep_nulls)

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 void	ExecEvalExprNoReturn (ExprState state, ExprContext econtext)

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

static void	ExecEvalExprNoReturnSwitchContext (ExprState state, ExprContext econtext)

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)

const TupleTableSlotOps *	ExecGetCommonSlotOps (PlanState **planstates, int nplans)

const TupleTableSlotOps *	ExecGetCommonChildSlotOps (PlanState *ps)

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, Bitmapset unpruned_relids)

void	ExecCloseRangeTableRelations (EState *estate)

void	ExecCloseResultRelations (EState *estate)

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

Relation	ExecGetRangeTableRelation (EState *estate, Index rti, bool isResultRel)

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)

TupleTableSlot *	ExecGetAllNullSlot (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, ItemPointer tupleid, List arbiterIndexes)

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

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 609 of file executor.h.

◆ EvalPlanQualSetSlot

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

Definition at line 246 of file executor.h.

◆ EXEC_FLAG_BACKWARD

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

Definition at line 69 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_GENERIC

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

Definition at line 67 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_ONLY

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

Definition at line 66 of file executor.h.

◆ EXEC_FLAG_MARK

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

Definition at line 70 of file executor.h.

◆ EXEC_FLAG_REWIND

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

Definition at line 68 of file executor.h.

◆ EXEC_FLAG_SKIP_TRIGGERS

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

Definition at line 71 of file executor.h.

◆ EXEC_FLAG_WITH_NO_DATA

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

Definition at line 72 of file executor.h.

◆ GetPerTupleExprContext

#define GetPerTupleExprContext ( estate )

Value:

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

Definition at line 637 of file executor.h.

◆ GetPerTupleMemoryContext

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

Definition at line 642 of file executor.h.

◆ ResetExprContext

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

Definition at line 631 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 646 of file executor.h.

Typedef Documentation

◆ ExecScanAccessMtd

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

Definition at line 560 of file executor.h.

◆ ExecScanRecheckMtd

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

Definition at line 561 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)

Definition at line 80 of file executor.h.

◆ ExecutorStart_hook_type

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

Definition at line 76 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 2442 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,
		const TupleTableSlotOps *	inputOps,
		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 161 of file execGrouping.c.

{
    TupleHashTable hashtable;
    Size        entrysize = sizeof(TupleHashEntryData) + additionalsize;
    Size        hash_mem_limit;
    MemoryContext oldcontext;
    bool        allow_jit;
    uint32      hash_iv = 0;
 
    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_collations = collations;
    hashtable->tablecxt = tablecxt;
    hashtable->tempcxt = tempcxt;
    hashtable->tableslot = NULL;    /* will be made on first lookup */
    hashtable->inputslot = NULL;
    hashtable->in_hash_expr = 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)
        hash_iv = murmurhash32(ParallelWorkerNumber);
 
    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 caller fails to make the metacxt different from the tablecxt,
     * allowing JIT would lead to the generated functions to a) live longer
     * than the query or 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 hash ExprState for all columns */
    hashtable->tab_hash_expr = ExecBuildHash32FromAttrs(inputDesc,
                                                        inputOps,
                                                        hashfunctions,
                                                        collations,
                                                        numCols,
                                                        keyColIdx,
                                                        allow_jit ? parent : NULL,
                                                        hash_iv);
 
    /* build comparator for all columns */
    hashtable->tab_eq_func = ExecBuildGroupingEqual(inputDesc, inputDesc,
                                                    inputOps,
                                                    &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(), and buildSubPlanHash().

◆ 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 957 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 729 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 if the relation does not
     * publish UPDATEs or DELETEs, or all the following conditions are
     * satisfied:
     *
     * 1. 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.
     *
     * 2. All columns, referenced in the column lists are valid - i.e. when
     * all columns referenced in the REPLICA IDENTITY are covered by the
     * column list.
     *
     * 3. All generated columns in REPLICA IDENTITY of the relation, are valid
     * - i.e. when all these generated columns are published.
     *
     * XXX We could optimize it by first checking whether any of the
     * publications have a row filter or column list for this relation, or if
     * the relation contains a generated column. If none of these exist and
     * the 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_UPDATE && !pubdesc.gencols_valid_for_update)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("cannot update table \"%s\"",
                        RelationGetRelationName(rel)),
                 errdetail("Replica identity must not contain unpublished generated columns.")));
    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.")));
    else if (cmd == CMD_DELETE && !pubdesc.gencols_valid_for_delete)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                 errmsg("cannot delete from table \"%s\"",
                        RelationGetRelationName(rel)),
                 errdetail("Replica identity must not contain unpublished generated columns.")));
 
    /* 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, PublicationDesc::gencols_valid_for_delete, PublicationDesc::gencols_valid_for_update, 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 839 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,
		List *	mergeActions
	)

Definition at line 1149 of file execMain.c.

{
    Relation    resultRel = resultRelInfo->ri_RelationDesc;
    FdwRoutine *fdwroutine;
 
    /* Expect a fully-formed ResultRelInfo from InitResultRelInfo(). */
    Assert(resultRelInfo->ri_needLockTagTuple ==
           IsInplaceUpdateRelation(resultRel));
 
    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.  Otherwise,
             * complain, but omit errdetail because we haven't got the
             * information handy (and given that it really shouldn't happen,
             * it's not worth great exertion to get).
             */
            if (!view_has_instead_trigger(resultRel, operation, mergeActions))
                error_view_not_updatable(resultRel, operation, mergeActions,
                                         NULL);
            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 Assert(), CheckCmdReplicaIdentity(), CMD_DELETE, CMD_INSERT, CMD_UPDATE, elog, ereport, errcode(), errmsg(), ERROR, error_view_not_updatable(), FdwRoutine::ExecForeignDelete, FdwRoutine::ExecForeignInsert, FdwRoutine::ExecForeignUpdate, FdwRoutine::IsForeignRelUpdatable, IsInplaceUpdateRelation(), MatViewIncrementalMaintenanceIsEnabled(), RelationData::rd_rel, RelationGetRelationName, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_needLockTagTuple, ResultRelInfo::ri_RelationDesc, and view_has_instead_trigger().

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

◆ CreateExecutorState()

EState * CreateExecutorState ( void )

Definition at line 88 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_part_prune_infos = NIL;
 
    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_aborted = 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_parallel_workers_to_launch = 0;
    estate->es_parallel_workers_launched = 0;
 
    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_aborted, 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_parallel_workers_launched, EState::es_parallel_workers_to_launch, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_part_prune_infos, 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(), ATExecAddColumn(), 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(), tuplesort_begin_cluster(), and validateDomainCheckConstraint().

◆ CreateExprContext()

ExprContext * CreateExprContext ( EState * estate )

Definition at line 308 of file execUtils.c.

{
    return CreateExprContextInternal(estate, ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

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

◆ CreateStandaloneExprContext()

ExprContext * CreateStandaloneExprContext ( void )

Definition at line 359 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 BuildTupleHashTable(), domain_check_input(), and hypothetical_dense_rank_final().

◆ CreateWorkExprContext()

ExprContext * CreateWorkExprContext ( EState * estate )

Definition at line 323 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 (maxBlockSize > work_mem * (Size) 1024 / 16)
        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 2490 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 2462 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 2520 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 2610 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 2893 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 3134 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 2766 of file execMain.c.

{
    ExecAuxRowMark *earm = epqstate->relsubs_rowmark[rti - 1];
    ExecRowMark *erm;
    Datum       datum;
    bool        isNull;
 
    Assert(earm != NULL);
    Assert(epqstate->origslot != NULL);
 
    erm = earm->rowmark;
 
    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 2679 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 2877 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 2721 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 2738 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 678 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(), ExecDoInitialPruning(), ExecEvalWholeRowVar(), ExecGetRangeTableRelation(), ExecInitBitmapIndexScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), GetResultRTEPermissionInfo(), InitPlan(), postgresBeginForeignInsert(), postgresBeginForeignModify(), and postgresBeginForeignScan().

◆ ExecAssignExprContext()

void ExecAssignExprContext	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 487 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(), 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 585 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 81 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 94 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 694 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 2540 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 4465 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.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
        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.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
        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_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, FunctionCallInfoBaseData::args, Assert(), ExprEvalStep::attnum, collid, ExprEvalStep::d, EEO_FLAG_IS_QUAL, EEOP_DONE_RETURN, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, EEOP_NOT_DISTINCT, EEOP_OUTER_FETCHSOME, EEOP_OUTER_VAR, EEOP_QUAL, ExecComputeSlotInfo(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fcinfo_data, ExprEvalStep::fetch, ExprEvalStep::finfo, ExprEvalStep::fixed, fmgr_info(), fmgr_info_set_expr, ExprEvalStep::fn_addr, FmgrInfo::fn_addr, ExprEvalStep::func, get_func_name(), GetUserId(), InitFunctionCallInfoData, InvokeFunctionExecuteHook, NullableDatum::isnull, ExprEvalStep::jumpdone, ExprEvalStep::kind, ExprEvalStep::known_desc, lappend_int(), ExprEvalStep::last_var, lfirst_int, makeNode, ExprEvalStep::nargs, NIL, object_aclcheck(), OBJECT_FUNCTION, ExprEvalStep::opcode, palloc0(), ExprEvalStep::qualexpr, ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, TupleDescAttr(), NullableDatum::value, ExprEvalStep::var, VAR_RETURNING_DEFAULT, ExprEvalStep::varreturningtype, and ExprEvalStep::vartype.

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

◆ ExecBuildHash32Expr()

ExprState * ExecBuildHash32Expr	(	TupleDesc	desc,
		const TupleTableSlotOps *	ops,
		const Oid *	hashfunc_oids,
		const List *	collations,
		const List *	hash_exprs,
		const bool *	opstrict,
		PlanState *	parent,
		uint32	init_value,
		bool	keep_nulls
	)

Definition at line 4300 of file execExpr.c.

{
    ExprState  *state = makeNode(ExprState);
    ExprEvalStep scratch = {0};
    NullableDatum *iresult = NULL;
    List       *adjust_jumps = NIL;
    ListCell   *lc;
    ListCell   *lc2;
    intptr_t    strict_opcode;
    intptr_t    opcode;
    int         num_exprs = list_length(hash_exprs);
 
    Assert(num_exprs == list_length(collations));
 
    state->parent = parent;
 
    /* Insert setup steps as needed. */
    ExecCreateExprSetupSteps(state, (Node *) hash_exprs);
 
    /*
     * Make a place to store intermediate hash values between subsequent
     * hashing of individual expressions.  We only need this if there is more
     * than one expression to hash or an initial value plus one expression.
     */
    if ((int64) num_exprs + (init_value != 0) > 1)
        iresult = palloc(sizeof(NullableDatum));
 
    if (init_value == 0)
    {
        /*
         * No initial value, so we can assign the result of the hash function
         * for the first hash_expr without having to concern ourselves with
         * combining the result with any initial value.
         */
        strict_opcode = EEOP_HASHDATUM_FIRST_STRICT;
        opcode = EEOP_HASHDATUM_FIRST;
    }
    else
    {
        /*
         * Set up operation to set the initial value.  Normally we store this
         * in the intermediate hash value location, but if there are no exprs
         * to hash, store it in the ExprState's result field.
         */
        scratch.opcode = EEOP_HASHDATUM_SET_INITVAL;
        scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
        scratch.resvalue = num_exprs > 0 ? &iresult->value : &state->resvalue;
        scratch.resnull = num_exprs > 0 ? &iresult->isnull : &state->resnull;
 
        ExprEvalPushStep(state, &scratch);
 
        /*
         * When using an initial value use the NEXT32/NEXT32_STRICT ops as the
         * FIRST/FIRST_STRICT ops would overwrite the stored initial value.
         */
        strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
        opcode = EEOP_HASHDATUM_NEXT32;
    }
 
    forboth(lc, hash_exprs, lc2, collations)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        FmgrInfo   *finfo;
        FunctionCallInfo fcinfo;
        int         i = foreach_current_index(lc);
        Oid         funcid;
        Oid         inputcollid = lfirst_oid(lc2);
 
        funcid = hashfunc_oids[i];
 
        /* Allocate hash function lookup data. */
        finfo = palloc0(sizeof(FmgrInfo));
        fcinfo = palloc0(SizeForFunctionCallInfo(1));
 
        fmgr_info(funcid, finfo);
 
        /*
         * Build the steps to evaluate the hash function's argument have it so
         * the value of that is stored in the 0th argument of the hash func.
         */
        ExecInitExprRec(expr,
                        state,
                        &fcinfo->args[0].value,
                        &fcinfo->args[0].isnull);
 
        if (i == num_exprs - 1)
        {
            /* the result for hashing the final expr is stored in the state */
            scratch.resvalue = &state->resvalue;
            scratch.resnull = &state->resnull;
        }
        else
        {
            Assert(iresult != NULL);
 
            /* intermediate values are stored in an intermediate result */
            scratch.resvalue = &iresult->value;
            scratch.resnull = &iresult->isnull;
        }
 
        /*
         * NEXT32 opcodes need to look at the intermediate result.  We might
         * as well just set this for all ops.  FIRSTs won't look at it.
         */
        scratch.d.hashdatum.iresult = iresult;
 
        /* Initialize function call parameter structure too */
        InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);
 
        scratch.d.hashdatum.finfo = finfo;
        scratch.d.hashdatum.fcinfo_data = fcinfo;
        scratch.d.hashdatum.fn_addr = finfo->fn_addr;
 
        scratch.opcode = opstrict[i] && !keep_nulls ? strict_opcode : opcode;
        scratch.d.hashdatum.jumpdone = -1;
 
        ExprEvalPushStep(state, &scratch);
        adjust_jumps = lappend_int(adjust_jumps, state->steps_len - 1);
 
        /*
         * For subsequent keys we must combine the hash value with the
         * previous hashes.
         */
        strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
        opcode = EEOP_HASHDATUM_NEXT32;
    }
 
    /* adjust jump targets */
    foreach(lc, adjust_jumps)
    {
        ExprEvalStep *as = &state->steps[lfirst_int(lc)];
 
        Assert(as->opcode == EEOP_HASHDATUM_FIRST ||
               as->opcode == EEOP_HASHDATUM_FIRST_STRICT ||
               as->opcode == EEOP_HASHDATUM_NEXT32 ||
               as->opcode == EEOP_HASHDATUM_NEXT32_STRICT);
        Assert(as->d.hashdatum.jumpdone == -1);
        as->d.hashdatum.jumpdone = state->steps_len;
    }
 
    scratch.resvalue = NULL;
    scratch.resnull = NULL;
    scratch.opcode = EEOP_DONE_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References FunctionCallInfoBaseData::args, Assert(), ExprEvalStep::d, EEOP_DONE_RETURN, EEOP_HASHDATUM_FIRST, EEOP_HASHDATUM_FIRST_STRICT, EEOP_HASHDATUM_NEXT32, EEOP_HASHDATUM_NEXT32_STRICT, EEOP_HASHDATUM_SET_INITVAL, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fcinfo_data, ExprEvalStep::finfo, fmgr_info(), ExprEvalStep::fn_addr, FmgrInfo::fn_addr, forboth, foreach_current_index, ExprEvalStep::hashdatum, ExprEvalStep::hashdatum_initvalue, i, ExprEvalStep::init_value, InitFunctionCallInfoData, ExprEvalStep::iresult, NullableDatum::isnull, ExprEvalStep::jumpdone, lappend_int(), lfirst, lfirst_int, lfirst_oid, list_length(), makeNode, NIL, ExprEvalStep::opcode, palloc(), palloc0(), ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, UInt32GetDatum(), and NullableDatum::value.

Referenced by ExecInitHashJoin().

◆ ExecBuildHash32FromAttrs()

ExprState * ExecBuildHash32FromAttrs	(	TupleDesc	desc,
		const TupleTableSlotOps *	ops,
		FmgrInfo *	hashfunctions,
		Oid *	collations,
		int	numCols,
		AttrNumber *	keyColIdx,
		PlanState *	parent,
		uint32	init_value
	)

Definition at line 4141 of file execExpr.c.

{
    ExprState  *state = makeNode(ExprState);
    ExprEvalStep scratch = {0};
    NullableDatum *iresult = NULL;
    intptr_t    opcode;
    AttrNumber  last_attnum = 0;
 
    Assert(numCols >= 0);
 
    state->parent = parent;
 
    /*
     * Make a place to store intermediate hash values between subsequent
     * hashing of individual columns.  We only need this if there is more than
     * one column to hash or an initial value plus one column.
     */
    if ((int64) numCols + (init_value != 0) > 1)
        iresult = palloc(sizeof(NullableDatum));
 
    /* find the highest attnum so we deform the tuple to that point */
    for (int i = 0; i < numCols; i++)
        last_attnum = Max(last_attnum, keyColIdx[i]);
 
    scratch.opcode = EEOP_INNER_FETCHSOME;
    scratch.d.fetch.last_var = last_attnum;
    scratch.d.fetch.fixed = false;
    scratch.d.fetch.kind = ops;
    scratch.d.fetch.known_desc = desc;
    if (ExecComputeSlotInfo(state, &scratch))
        ExprEvalPushStep(state, &scratch);
 
    if (init_value == 0)
    {
        /*
         * No initial value, so we can assign the result of the hash function
         * for the first attribute without having to concern ourselves with
         * combining the result with any initial value.
         */
        opcode = EEOP_HASHDATUM_FIRST;
    }
    else
    {
        /*
         * Set up operation to set the initial value.  Normally we store this
         * in the intermediate hash value location, but if there are no
         * columns to hash, store it in the ExprState's result field.
         */
        scratch.opcode = EEOP_HASHDATUM_SET_INITVAL;
        scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
        scratch.resvalue = numCols > 0 ? &iresult->value : &state->resvalue;
        scratch.resnull = numCols > 0 ? &iresult->isnull : &state->resnull;
 
        ExprEvalPushStep(state, &scratch);
 
        /*
         * When using an initial value use the NEXT32 ops as the FIRST ops
         * would overwrite the stored initial value.
         */
        opcode = EEOP_HASHDATUM_NEXT32;
    }
 
    for (int i = 0; i < numCols; i++)
    {
        FmgrInfo   *finfo;
        FunctionCallInfo fcinfo;
        Oid         inputcollid = collations[i];
        AttrNumber  attnum = keyColIdx[i] - 1;
 
        finfo = &hashfunctions[i];
        fcinfo = palloc0(SizeForFunctionCallInfo(1));
 
        /* Initialize function call parameter structure too */
        InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);
 
        /*
         * Fetch inner Var for this attnum and store it in the 1st arg of the
         * hash func.
         */
        scratch.opcode = EEOP_INNER_VAR;
        scratch.resvalue = &fcinfo->args[0].value;
        scratch.resnull = &fcinfo->args[0].isnull;
        scratch.d.var.attnum = attnum;
        scratch.d.var.vartype = TupleDescAttr(desc, attnum)->atttypid;
        scratch.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
 
        ExprEvalPushStep(state, &scratch);
 
        /* Call the hash function */
        scratch.opcode = opcode;
 
        if (i == numCols - 1)
        {
            /*
             * The result for hashing the final column is stored in the
             * ExprState.
             */
            scratch.resvalue = &state->resvalue;
            scratch.resnull = &state->resnull;
        }
        else
        {
            Assert(iresult != NULL);
 
            /* intermediate values are stored in an intermediate result */
            scratch.resvalue = &iresult->value;
            scratch.resnull = &iresult->isnull;
        }
 
        /*
         * NEXT32 opcodes need to look at the intermediate result.  We might
         * as well just set this for all ops.  FIRSTs won't look at it.
         */
        scratch.d.hashdatum.iresult = iresult;
 
        scratch.d.hashdatum.finfo = finfo;
        scratch.d.hashdatum.fcinfo_data = fcinfo;
        scratch.d.hashdatum.fn_addr = finfo->fn_addr;
        scratch.d.hashdatum.jumpdone = -1;
 
        ExprEvalPushStep(state, &scratch);
 
        /* subsequent attnums must be combined with the previous */
        opcode = EEOP_HASHDATUM_NEXT32;
    }
 
    scratch.resvalue = NULL;
    scratch.resnull = NULL;
    scratch.opcode = EEOP_DONE_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References FunctionCallInfoBaseData::args, Assert(), attnum, ExprEvalStep::attnum, ExprEvalStep::d, EEOP_DONE_RETURN, EEOP_HASHDATUM_FIRST, EEOP_HASHDATUM_NEXT32, EEOP_HASHDATUM_SET_INITVAL, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, ExecComputeSlotInfo(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fcinfo_data, ExprEvalStep::fetch, ExprEvalStep::finfo, ExprEvalStep::fixed, ExprEvalStep::fn_addr, FmgrInfo::fn_addr, ExprEvalStep::hashdatum, ExprEvalStep::hashdatum_initvalue, i, ExprEvalStep::init_value, InitFunctionCallInfoData, ExprEvalStep::iresult, NullableDatum::isnull, ExprEvalStep::jumpdone, ExprEvalStep::kind, ExprEvalStep::known_desc, ExprEvalStep::last_var, makeNode, Max, ExprEvalStep::opcode, palloc(), palloc0(), ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, TupleDescAttr(), UInt32GetDatum(), NullableDatum::value, ExprEvalStep::var, VAR_RETURNING_DEFAULT, ExprEvalStep::varreturningtype, and ExprEvalStep::vartype.

Referenced by BuildTupleHashTable(), and ExecInitSubPlan().

◆ 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 4624 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.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
        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.d.var.varreturningtype = VAR_RETURNING_DEFAULT;
        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_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References ACL_EXECUTE, aclcheck_error(), ACLCHECK_OK, FunctionCallInfoBaseData::args, Assert(), ExprEvalStep::attnum, collid, ExprEvalStep::d, EEO_FLAG_IS_QUAL, EEOP_DONE_RETURN, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, EEOP_NOT_DISTINCT, EEOP_OUTER_FETCHSOME, EEOP_OUTER_VAR, EEOP_QUAL, ExecComputeSlotInfo(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fcinfo_data, ExprEvalStep::fetch, ExprEvalStep::finfo, ExprEvalStep::fixed, fmgr_info(), fmgr_info_set_expr, ExprEvalStep::fn_addr, FmgrInfo::fn_addr, ExprEvalStep::func, get_func_name(), GetUserId(), InitFunctionCallInfoData, InvokeFunctionExecuteHook, NullableDatum::isnull, ExprEvalStep::jumpdone, ExprEvalStep::kind, ExprEvalStep::known_desc, lappend_int(), ExprEvalStep::last_var, lfirst_int, list_length(), makeNode, ExprEvalStep::nargs, NIL, object_aclcheck(), OBJECT_FUNCTION, ExprEvalStep::opcode, palloc0(), ExprEvalStep::qualexpr, ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, TupleDescAttr(), NullableDatum::value, ExprEvalStep::var, VAR_RETURNING_DEFAULT, ExprEvalStep::varreturningtype, and ExprEvalStep::vartype.

Referenced by ExecInitMemoize().

◆ ExecBuildProjectionInfo()

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

Definition at line 370 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, or the
                     * old/new tuple slot, if old/new values were requested.
                     */
                    switch (variable->varreturningtype)
                    {
                        case VAR_RETURNING_DEFAULT:
                            scratch.opcode = EEOP_ASSIGN_SCAN_VAR;
                            break;
                        case VAR_RETURNING_OLD:
                            scratch.opcode = EEOP_ASSIGN_OLD_VAR;
                            state->flags |= EEO_FLAG_HAS_OLD;
                            break;
                        case VAR_RETURNING_NEW:
                            scratch.opcode = EEOP_ASSIGN_NEW_VAR;
                            state->flags |= EEO_FLAG_HAS_NEW;
                            break;
                    }
                    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_NO_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return projInfo;
}

References ExprEvalStep::assign_tmp, ExprEvalStep::assign_var, attnum, ExprEvalStep::attnum, ExprEvalStep::d, EEO_FLAG_HAS_NEW, EEO_FLAG_HAS_OLD, EEOP_ASSIGN_INNER_VAR, EEOP_ASSIGN_NEW_VAR, EEOP_ASSIGN_OLD_VAR, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_ASSIGN_TMP, EEOP_ASSIGN_TMP_MAKE_RO, EEOP_DONE_NO_RETURN, 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, ExprEvalStep::resultnum, TupleDescAttr(), ExprState::type, VAR_RETURNING_DEFAULT, VAR_RETURNING_NEW, and VAR_RETURNING_OLD.

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

◆ ExecBuildSlotValueDescription()

char * ExecBuildSlotValueDescription	(	Oid	reloid,
		TupleTableSlot *	slot,
		TupleDesc	tupdesc,
		Bitmapset *	modifiedCols,
		int	maxfieldlen
	)

Definition at line 2352 of file execMain.c.

{
    StringInfoData buf;
    StringInfoData collist;
    bool        write_comma = false;
    bool        write_comma_collist = false;
    int         i;
    AclResult   aclresult;
    bool        table_perm = false;
    bool        any_perm = false;
 
    /*
     * Check if RLS is enabled and should be active for the relation; if so,
     * then don't return anything.  Otherwise, go through normal permission
     * checks.
     */
    if (check_enable_rls(reloid, InvalidOid, true) == RLS_ENABLED)
        return NULL;
 
    initStringInfo(&buf);
 
    appendStringInfoChar(&buf, '(');
 
    /*
     * Check if the user has permissions to see the row.  Table-level SELECT
     * allows access to all columns.  If the user does not have table-level
     * SELECT then we check each column and include those the user has SELECT
     * rights on.  Additionally, we always include columns the user provided
     * data for.
     */
    aclresult = pg_class_aclcheck(reloid, GetUserId(), ACL_SELECT);
    if (aclresult != ACLCHECK_OK)
    {
        /* Set up the buffer for the column list */
        initStringInfo(&collist);
        appendStringInfoChar(&collist, '(');
    }
    else
        table_perm = any_perm = true;
 
    /* Make sure the tuple is fully deconstructed */
    slot_getallattrs(slot);
 
    for (i = 0; i < tupdesc->natts; i++)
    {
        bool        column_perm = false;
        char       *val;
        int         vallen;
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
 
        /* ignore dropped columns */
        if (att->attisdropped)
            continue;
 
        if (!table_perm)
        {
            /*
             * No table-level SELECT, so need to make sure they either have
             * SELECT rights on the column or that they have provided the data
             * for the column.  If not, omit this column from the error
             * message.
             */
            aclresult = pg_attribute_aclcheck(reloid, att->attnum,
                                              GetUserId(), ACL_SELECT);
            if (bms_is_member(att->attnum - FirstLowInvalidHeapAttributeNumber,
                              modifiedCols) || aclresult == ACLCHECK_OK)
            {
                column_perm = any_perm = true;
 
                if (write_comma_collist)
                    appendStringInfoString(&collist, ", ");
                else
                    write_comma_collist = true;
 
                appendStringInfoString(&collist, NameStr(att->attname));
            }
        }
 
        if (table_perm || column_perm)
        {
            if (att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
                val = "virtual";
            else if (slot->tts_isnull[i])
                val = "null";
            else
            {
                Oid         foutoid;
                bool        typisvarlena;
 
                getTypeOutputInfo(att->atttypid,
                                  &foutoid, &typisvarlena);
                val = OidOutputFunctionCall(foutoid, slot->tts_values[i]);
            }
 
            if (write_comma)
                appendStringInfoString(&buf, ", ");
            else
                write_comma = true;
 
            /* truncate if needed */
            vallen = strlen(val);
            if (vallen <= maxfieldlen)
                appendBinaryStringInfo(&buf, val, vallen);
            else
            {
                vallen = pg_mbcliplen(val, vallen, maxfieldlen);
                appendBinaryStringInfo(&buf, val, vallen);
                appendStringInfoString(&buf, "...");
            }
        }
    }
 
    /* If we end up with zero columns being returned, then return NULL. */
    if (!any_perm)
        return NULL;
 
    appendStringInfoChar(&buf, ')');
 
    if (!table_perm)
    {
        appendStringInfoString(&collist, ") = ");
        appendBinaryStringInfo(&collist, buf.data, buf.len);
 
        return collist.data;
    }
 
    return buf.data;
}

References ACL_SELECT, ACLCHECK_OK, appendBinaryStringInfo(), appendStringInfoChar(), appendStringInfoString(), bms_is_member(), buf, check_enable_rls(), StringInfoData::data, FirstLowInvalidHeapAttributeNumber, getTypeOutputInfo(), GetUserId(), i, initStringInfo(), InvalidOid, NameStr, TupleDescData::natts, OidOutputFunctionCall(), pg_attribute_aclcheck(), pg_class_aclcheck(), pg_mbcliplen(), RLS_ENABLED, slot_getallattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, TupleDescAttr(), and val.

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

◆ ExecBuildUpdateProjection()

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

Definition at line 547 of file execExpr.c.

{
    ProjectionInfo *projInfo = makeNode(ProjectionInfo);
    ExprState  *state;
    int         nAssignableCols;
    bool        sawJunk;
    Bitmapset  *assignedCols;
    ExprSetupInfo deform = {0, 0, 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--)
    {
        CompactAttribute *attr = TupleDescCompactAttr(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++)
    {
        CompactAttribute *attr = TupleDescCompactAttr(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_NO_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return projInfo;
}

References Assert(), ExprEvalStep::assign_tmp, ExprEvalStep::assign_var, CompactAttribute::attisdropped, attnum, ExprEvalStep::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_NO_RETURN, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, ExecInitExprRec(), ExecPushExprSetupSteps(), ExecReadyExpr(), TargetEntry::expr, expr_setup_walker(), ExprEvalPushStep(), exprType(), forboth, format_type_be(), ExprEvalStep::isnull, 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::resultnum, ExprEvalStep::resvalue, TupleDescAttr(), TupleDescCompactAttr(), ExprState::type, and ExprEvalStep::value.

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

◆ ExecCheck()

bool ExecCheck	(	ExprState *	state,
		ExprContext *	econtext
	)

Definition at line 872 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,
		ItemPointer	tupleid,
		List *	arbiterIndexes
	)

Definition at line 543 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, tupleid,
                                                 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(), and FindConflictTuple().

◆ ExecCheckPermissions()

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

Definition at line 658 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));
 
            /*
             * Ensure that we have at least an AccessShareLock on relations
             * whose permissions need to be checked.
             *
             * Skip this check in a parallel worker because locks won't be
             * taken until ExecInitNode() performs plan initialization.
             *
             * XXX: ExecCheckPermissions() in a parallel worker may be
             * redundant with the checks done in the leader process, so this
             * should be reviewed to ensure it’s necessary.
             */
            Assert(IsParallelWorker() ||
                   CheckRelationOidLockedByMe(rte->relid, AccessShareLock,
                                              true));
 
            (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 AccessShareLock, aclcheck_error(), ACLCHECK_NO_PRIV, Assert(), bms_add_member(), bms_is_member(), bms_num_members(), CheckRelationOidLockedByMe(), ExecCheckOneRelPerms(), ExecutorCheckPerms_hook, get_rel_name(), get_rel_relkind(), get_relkind_objtype(), getRTEPermissionInfo(), IsParallelWorker, lfirst_node, list_length(), OidIsValid, RangeTblEntry::relid, RTEPermissionInfo::relid, RTE_RELATION, RTE_SUBQUERY, and RangeTblEntry::rtekind.

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

◆ ExecCleanTargetListLength()

int ExecCleanTargetListLength ( List * targetlist )

Definition at line 1187 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 2137 of file execTuples.c.

{
    return ExecTypeFromTLInternal(targetList, true);
}

References ExecTypeFromTLInternal().

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

◆ ExecCloseIndices()

void ExecCloseIndices ( ResultRelInfo * resultRelInfo )

Definition at line 239 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++)
    {
        /* This Assert will fail if ExecCloseIndices is called twice */
        Assert(indexDescs[i] != NULL);
 
        /* 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);
 
        /* Mark the index as closed */
        indexDescs[i] = NULL;
    }
 
    /*
     * We don't attempt to free the IndexInfo data structures or the arrays,
     * instead assuming that such stuff will be cleaned up automatically in
     * FreeExecutorState.
     */
}

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

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_update_internal(), CatalogCloseIndexes(), ExecCleanupTupleRouting(), and ExecCloseResultRelations().

◆ ExecCloseRangeTableRelations()

void ExecCloseRangeTableRelations ( EState * estate )

Definition at line 1707 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 1647 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 605 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 2054 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 706 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_heaptid.
             */
            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 562 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 374 of file executor.h.

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

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

◆ ExecEvalExprNoReturn()

static void ExecEvalExprNoReturn	(	ExprState *	state,
		ExprContext *	econtext
	)

inlinestatic

Definition at line 399 of file executor.h.

{
    PG_USED_FOR_ASSERTS_ONLY Datum retDatum;
 
    retDatum = state->evalfunc(state, econtext, NULL);
 
    Assert(retDatum == (Datum) 0);
}

References Assert(), and PG_USED_FOR_ASSERTS_ONLY.

Referenced by ExecEvalExprNoReturnSwitchContext().

◆ ExecEvalExprNoReturnSwitchContext()

static void ExecEvalExprNoReturnSwitchContext	(	ExprState *	state,
		ExprContext *	econtext
	)

inlinestatic

Definition at line 439 of file executor.h.

{
    MemoryContext oldContext;
 
    oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
    ExecEvalExprNoReturn(state, econtext);
    MemoryContextSwitchTo(oldContext);
}

References ExprContext::ecxt_per_tuple_memory, ExecEvalExprNoReturn(), and MemoryContextSwitchTo().

Referenced by advance_aggregates(), and ExecProject().

◆ ExecEvalExprSwitchContext()

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

inlinestatic

Definition at line 417 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 calculate_frame_offsets(), compute_expr_stats(), evaluate_expr(), EvaluateParams(), ExecCheck(), ExecHashJoinOuterGetTuple(), ExecParallelHashJoinOuterGetTuple(), ExecParallelHashJoinPartitionOuter(), ExecQual(), ExecScanSubPlan(), ExecuteCallStmt(), FormIndexDatum(), FormPartitionKeyDatum(), get_qual_for_range(), MultiExecParallelHash(), MultiExecPrivateHash(), operator_predicate_proof(), partkey_datum_from_expr(), pgoutput_row_filter_exec_expr(), recompute_limits(), tablesample_init(), TidListEval(), TidRangeEval(), and validateDomainCheckConstraint().

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

◆ ExecGetAllNullSlot()

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

Definition at line 1275 of file execUtils.c.

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

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

Referenced by ExecProcessReturning().

◆ ExecGetAllUpdatedCols()

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

Definition at line 1420 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 1502 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 1302 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(), ExecDelete(), and TransitionTableAddTuple().

◆ ExecGetCommonChildSlotOps()

const TupleTableSlotOps * ExecGetCommonChildSlotOps ( PlanState * ps )

Definition at line 565 of file execUtils.c.

{
    PlanState  *planstates[2];
 
    planstates[0] = outerPlanState(ps);
    planstates[1] = innerPlanState(ps);
    return ExecGetCommonSlotOps(planstates, 2);
}

References ExecGetCommonSlotOps(), innerPlanState, outerPlanState, and ps.

Referenced by build_hash_table().

◆ ExecGetCommonSlotOps()

const TupleTableSlotOps * ExecGetCommonSlotOps	(	PlanState **	planstates,
		int	nplans
	)

Definition at line 538 of file execUtils.c.

{
    const TupleTableSlotOps *result;
    bool        isfixed;
 
    if (nplans <= 0)
        return NULL;
    result = ExecGetResultSlotOps(planstates[0], &isfixed);
    if (!isfixed)
        return NULL;
    for (int i = 1; i < nplans; i++)
    {
        const TupleTableSlotOps *thisops;
 
        thisops = ExecGetResultSlotOps(planstates[i], &isfixed);
        if (!isfixed)
            return NULL;
        if (result != thisops)
            return NULL;
    }
    return result;
}

References ExecGetResultSlotOps(), and i.

Referenced by ExecGetCommonChildSlotOps(), ExecInitAppend(), and ExecInitMergeAppend().

◆ ExecGetExtraUpdatedCols()

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

Definition at line 1405 of file execUtils.c.

{
    /* Compute the info if we didn't already */
    if (!relinfo->ri_extraUpdatedCols_valid)
        ExecInitGenerated(relinfo, estate, CMD_UPDATE);
    return relinfo->ri_extraUpdatedCols;
}

References CMD_UPDATE, ExecInitGenerated(), ResultRelInfo::ri_extraUpdatedCols, and ResultRelInfo::ri_extraUpdatedCols_valid.

Referenced by ExecGetAllUpdatedCols(), and index_unchanged_by_update().

◆ ExecGetInsertedCols()

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

Definition at line 1363 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 build_tuple_value_details(), ExecConstraints(), ExecPartitionCheckEmitError(), and ExecWithCheckOptions().

◆ ExecGetJunkAttribute()

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

inlinestatic

Definition at line 185 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,
		bool	isResultRel
	)

Definition at line 827 of file execUtils.c.

{
    Relation    rel;
 
    Assert(rti > 0 && rti <= estate->es_range_table_size);
 
    if (!isResultRel && !bms_is_member(rti, estate->es_unpruned_relids))
        elog(ERROR, "trying to open a pruned relation");
 
    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(), bms_is_member(), CheckRelationLockedByMe(), elog, ERROR, EState::es_relations, EState::es_unpruned_relids, exec_rt_fetch(), IsParallelWorker, NoLock, RangeTblEntry::relid, RTE_RELATION, RangeTblEntry::rtekind, and table_open().

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

◆ ExecGetResultRelCheckAsUser()

Oid ExecGetResultRelCheckAsUser	(	ResultRelInfo *	relInfo,
		EState *	estate
	)

Definition at line 1491 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 506 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(), ExecGetCommonSlotOps(), ExecInitAgg(), ExecInitGroup(), ExecInitHashJoin(), ExecInitLimit(), ExecInitLockRows(), ExecInitMergeJoin(), and ExecInitSubqueryScan().

◆ ExecGetResultType()

TupleDesc ExecGetResultType ( PlanState * planstate )

Definition at line 497 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(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecSort(), ExecWorkTableScan(), initialize_phase(), InitPlan(), and switchToPresortedPrefixMode().

◆ ExecGetReturningSlot()

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

Definition at line 1250 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 1328 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(), ExecInsert(), and ExecPrepareTupleRouting().

◆ ExecGetTriggerNewSlot()

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

Definition at line 1228 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 1206 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 1426 of file execMain.c.

{
    ResultRelInfo *rInfo;
    ListCell   *l;
    Relation    rel;
    MemoryContext oldcontext;
 
    /* Search through the query result relations */
    foreach(l, estate->es_opened_result_relations)
    {
        rInfo = lfirst(l);
        if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
            return rInfo;
    }
 
    /*
     * Search through the result relations that were created during tuple
     * routing, if any.
     */
    foreach(l, estate->es_tuple_routing_result_relations)
    {
        rInfo = (ResultRelInfo *) lfirst(l);
        if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
            return rInfo;
    }
 
    /* Nope, but maybe we already made an extra ResultRelInfo for it */
    foreach(l, estate->es_trig_target_relations)
    {
        rInfo = (ResultRelInfo *) lfirst(l);
        if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
            return rInfo;
    }
    /* Nope, so we need a new one */
 
    /*
     * Open the target relation's relcache entry.  We assume that an
     * appropriate lock is still held by the backend from whenever the trigger
     * event got queued, so we need take no new lock here.  Also, we need not
     * recheck the relkind, so no need for CheckValidResultRel.
     */
    rel = table_open(relid, NoLock);
 
    /*
     * Make the new entry in the right context.
     */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
    rInfo = makeNode(ResultRelInfo);
    InitResultRelInfo(rInfo,
                      rel,
                      0,        /* dummy rangetable index */
                      rootRelInfo,
                      estate->es_instrument);
    estate->es_trig_target_relations =
        lappend(estate->es_trig_target_relations, rInfo);
    MemoryContextSwitchTo(oldcontext);
 
    /*
     * Currently, we don't need any index information in ResultRelInfos used
     * only for triggers, so no need to call ExecOpenIndices.
     */
 
    return rInfo;
}

References EState::es_instrument, EState::es_opened_result_relations, EState::es_query_cxt, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, InitResultRelInfo(), lappend(), lfirst, makeNode, MemoryContextSwitchTo(), NoLock, RelationGetRelid, ResultRelInfo::ri_RelationDesc, and table_open().

Referenced by afterTriggerInvokeEvents().

◆ ExecGetUpdatedCols()

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

Definition at line 1384 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->updatedCols);
    }
 
    return perminfo->updatedCols;
}

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

Referenced by build_tuple_value_details(), ExecConstraints(), ExecGetAllUpdatedCols(), ExecInitGenerated(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), and index_unchanged_by_update().

◆ ExecGetUpdateNewTuple()

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

Definition at line 791 of file nodeModifyTable.c.

{
    ProjectionInfo *newProj = relinfo->ri_projectNew;
    ExprContext *econtext;
 
    /* Use a few extra Asserts to protect against outside callers */
    Assert(relinfo->ri_projectNewInfoValid);
    Assert(planSlot != NULL && !TTS_EMPTY(planSlot));
    Assert(oldSlot != NULL && !TTS_EMPTY(oldSlot));
 
    econtext = newProj->pi_exprContext;
    econtext->ecxt_outertuple = planSlot;
    econtext->ecxt_scantuple = oldSlot;
    return ExecProject(newProj);
}

References Assert(), ExprContext::ecxt_outertuple, ExprContext::ecxt_scantuple, ExecProject(), ProjectionInfo::pi_exprContext, ResultRelInfo::ri_projectNew, ResultRelInfo::ri_projectNewInfoValid, and TTS_EMPTY.

Referenced by ExecBRUpdateTriggers(), ExecCrossPartitionUpdate(), ExecModifyTable(), and ExecUpdate().

◆ ExecInitCheck()

ExprState * ExecInitCheck	(	List *	qual,
		PlanState *	parent
	)

Definition at line 315 of file execExpr.c.

{
    /* short-circuit (here and in ExecCheck) for empty restriction list */
    if (qual == NIL)
        return NULL;
 
    Assert(IsA(qual, List));
 
    /*
     * Just convert the implicit-AND list to an explicit AND (if there's more
     * than one entry), and compile normally.  Unlike ExecQual, we can't
     * short-circuit on NULL results, so the regular AND behavior is needed.
     */
    return ExecInitExpr(make_ands_explicit(qual), parent);
}

References Assert(), ExecInitExpr(), IsA, make_ands_explicit(), and NIL.

Referenced by ExecPrepareCheck().

◆ ExecInitExpr()

ExprState * ExecInitExpr	(	Expr *	node,
		PlanState *	parent
	)

Definition at line 143 of file execExpr.c.

{
    ExprState  *state;
    ExprEvalStep scratch = {0};
 
    /* Special case: NULL expression produces a NULL ExprState pointer */
    if (node == NULL)
        return NULL;
 
    /* Initialize ExprState with empty step list */
    state = makeNode(ExprState);
    state->expr = node;
    state->parent = parent;
    state->ext_params = NULL;
 
    /* Insert setup steps as needed */
    ExecCreateExprSetupSteps(state, (Node *) node);
 
    /* Compile the expression proper */
    ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
 
    /* Finally, append a DONE step */
    scratch.opcode = EEOP_DONE_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References EEOP_DONE_RETURN, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), ExprEvalPushStep(), makeNode, and ExprEvalStep::opcode.

Referenced by ATRewriteTable(), BeginCopyFrom(), evaluate_expr(), ExecIndexBuildScanKeys(), ExecInitCheck(), ExecInitExprList(), ExecInitExprRec(), ExecInitLimit(), ExecInitMemoize(), ExecInitProjectSet(), ExecInitSampleScan(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitTableFunctionResult(), ExecInitWindowAgg(), ExecPrepareExpr(), get_cast_hashentry(), get_qual_for_range(), InitPartitionPruneContext(), MakeTidOpExpr(), MJExamineQuals(), operator_predicate_proof(), prep_domain_constraints(), slot_fill_defaults(), and TidExprListCreate().

◆ ExecInitExprList()

List * ExecInitExprList	(	List *	nodes,
		PlanState *	parent
	)

Definition at line 335 of file execExpr.c.

{
    List       *result = NIL;
    ListCell   *lc;
 
    foreach(lc, nodes)
    {
        Expr       *e = lfirst(lc);
 
        result = lappend(result, ExecInitExpr(e, parent));
    }
 
    return result;
}

References ExecInitExpr(), lappend(), lfirst, and NIL.

Referenced by ExecInitAgg(), ExecInitExprRec(), ExecInitFunctionResultSet(), ExecInitIndexScan(), ExecInitSampleScan(), ExecInitTableFuncScan(), ExecInitTableFunctionResult(), ExecInitValuesScan(), prepare_query_params(), and ValuesNext().

◆ ExecInitExprWithParams()

ExprState * ExecInitExprWithParams	(	Expr *	node,
		ParamListInfo	ext_params
	)

Definition at line 180 of file execExpr.c.

{
    ExprState  *state;
    ExprEvalStep scratch = {0};
 
    /* Special case: NULL expression produces a NULL ExprState pointer */
    if (node == NULL)
        return NULL;
 
    /* Initialize ExprState with empty step list */
    state = makeNode(ExprState);
    state->expr = node;
    state->parent = NULL;
    state->ext_params = ext_params;
 
    /* Insert setup steps as needed */
    ExecCreateExprSetupSteps(state, (Node *) node);
 
    /* Compile the expression proper */
    ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
 
    /* Finally, append a DONE step */
    scratch.opcode = EEOP_DONE_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References EEOP_DONE_RETURN, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), ExprEvalPushStep(), makeNode, and ExprEvalStep::opcode.

Referenced by exec_eval_simple_expr(), and InitPartitionPruneContext().

◆ ExecInitExtraTupleSlot()

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

Definition at line 2018 of file execTuples.c.

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

References EState::es_tupleTable, and ExecAllocTableSlot().

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

◆ ExecInitFunctionResultSet()

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

Definition at line 444 of file execSRF.c.

{
    SetExprState *state = makeNode(SetExprState);
 
    state->funcReturnsSet = true;
    state->expr = expr;
    state->func.fn_oid = InvalidOid;
 
    /*
     * Initialize metadata.  The expression node could be either a FuncExpr or
     * an OpExpr.
     */
    if (IsA(expr, FuncExpr))
    {
        FuncExpr   *func = (FuncExpr *) expr;
 
        state->args = ExecInitExprList(func->args, parent);
        init_sexpr(func->funcid, func->inputcollid, expr, state, parent,
                   econtext->ecxt_per_query_memory, true, true);
    }
    else if (IsA(expr, OpExpr))
    {
        OpExpr     *op = (OpExpr *) expr;
 
        state->args = ExecInitExprList(op->args, parent);
        init_sexpr(op->opfuncid, op->inputcollid, expr, state, parent,
                   econtext->ecxt_per_query_memory, true, true);
    }
    else
        elog(ERROR, "unrecognized node type: %d",
             (int) nodeTag(expr));
 
    /* shouldn't get here unless the selected function returns set */
    Assert(state->func.fn_retset);
 
    return state;
}

References FuncExpr::args, OpExpr::args, Assert(), ExprContext::ecxt_per_query_memory, elog, ERROR, ExecInitExprList(), FuncExpr::funcid, init_sexpr(), InvalidOid, IsA, makeNode, and nodeTag.

Referenced by ExecInitProjectSet().

◆ ExecInitJunkFilter()

JunkFilter * ExecInitJunkFilter	(	List *	targetList,
		TupleTableSlot *	slot
	)

Definition at line 60 of file execJunk.c.

{
    JunkFilter *junkfilter;
    TupleDesc   cleanTupType;
    int         cleanLength;
    AttrNumber *cleanMap;
 
    /*
     * Compute the tuple descriptor for the cleaned tuple.
     */
    cleanTupType = ExecCleanTypeFromTL(targetList);
 
    /*
     * Use the given slot, or make a new slot if we weren't given one.
     */
    if (slot)
        ExecSetSlotDescriptor(slot, cleanTupType);
    else
        slot = MakeSingleTupleTableSlot(cleanTupType, &TTSOpsVirtual);
 
    /*
     * Now calculate the mapping between the original tuple's attributes and
     * the "clean" tuple's attributes.
     *
     * The "map" is an array of "cleanLength" attribute numbers, i.e. one
     * entry for every attribute of the "clean" tuple. The value of this entry
     * is the attribute number of the corresponding attribute of the
     * "original" tuple.  (Zero indicates a NULL output attribute, but we do
     * not use that feature in this routine.)
     */
    cleanLength = cleanTupType->natts;
    if (cleanLength > 0)
    {
        AttrNumber  cleanResno;
        ListCell   *t;
 
        cleanMap = (AttrNumber *) palloc(cleanLength * sizeof(AttrNumber));
        cleanResno = 0;
        foreach(t, targetList)
        {
            TargetEntry *tle = lfirst(t);
 
            if (!tle->resjunk)
            {
                cleanMap[cleanResno] = tle->resno;
                cleanResno++;
            }
        }
        Assert(cleanResno == cleanLength);
    }
    else
        cleanMap = NULL;
 
    /*
     * Finally create and initialize the JunkFilter struct.
     */
    junkfilter = makeNode(JunkFilter);
 
    junkfilter->jf_targetList = targetList;
    junkfilter->jf_cleanTupType = cleanTupType;
    junkfilter->jf_cleanMap = cleanMap;
    junkfilter->jf_resultSlot = slot;
 
    return junkfilter;
}

References Assert(), ExecCleanTypeFromTL(), ExecSetSlotDescriptor(), JunkFilter::jf_cleanMap, JunkFilter::jf_cleanTupType, JunkFilter::jf_resultSlot, JunkFilter::jf_targetList, lfirst, makeNode, MakeSingleTupleTableSlot(), TupleDescData::natts, palloc(), TargetEntry::resno, and TTSOpsVirtual.

Referenced by ExecInitWholeRowVar(), init_sql_fcache(), and InitPlan().

◆ ExecInitJunkFilterConversion()

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

Definition at line 137 of file execJunk.c.

{
    JunkFilter *junkfilter;
    int         cleanLength;
    AttrNumber *cleanMap;
    ListCell   *t;
    int         i;
 
    /*
     * Use the given slot, or make a new slot if we weren't given one.
     */
    if (slot)
        ExecSetSlotDescriptor(slot, cleanTupType);
    else
        slot = MakeSingleTupleTableSlot(cleanTupType, &TTSOpsVirtual);
 
    /*
     * Calculate the mapping between the original tuple's attributes and the
     * "clean" tuple's attributes.
     *
     * The "map" is an array of "cleanLength" attribute numbers, i.e. one
     * entry for every attribute of the "clean" tuple. The value of this entry
     * is the attribute number of the corresponding attribute of the
     * "original" tuple.  We store zero for any deleted attributes, marking
     * that a NULL is needed in the output tuple.
     */
    cleanLength = cleanTupType->natts;
    if (cleanLength > 0)
    {
        cleanMap = (AttrNumber *) palloc0(cleanLength * sizeof(AttrNumber));
        t = list_head(targetList);
        for (i = 0; i < cleanLength; i++)
        {
            if (TupleDescCompactAttr(cleanTupType, i)->attisdropped)
                continue;       /* map entry is already zero */
            for (;;)
            {
                TargetEntry *tle = lfirst(t);
 
                t = lnext(targetList, t);
                if (!tle->resjunk)
                {
                    cleanMap[i] = tle->resno;
                    break;
                }
            }
        }
    }
    else
        cleanMap = NULL;
 
    /*
     * Finally create and initialize the JunkFilter struct.
     */
    junkfilter = makeNode(JunkFilter);
 
    junkfilter->jf_targetList = targetList;
    junkfilter->jf_cleanTupType = cleanTupType;
    junkfilter->jf_cleanMap = cleanMap;
    junkfilter->jf_resultSlot = slot;
 
    return junkfilter;
}

References ExecSetSlotDescriptor(), i, JunkFilter::jf_cleanMap, JunkFilter::jf_cleanTupType, JunkFilter::jf_resultSlot, JunkFilter::jf_targetList, lfirst, list_head(), lnext(), makeNode, MakeSingleTupleTableSlot(), TupleDescData::natts, palloc0(), TargetEntry::resno, TTSOpsVirtual, and TupleDescCompactAttr().

Referenced by init_sql_fcache().

◆ ExecInitNode()

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

Definition at line 142 of file execProcnode.c.

{
    PlanState  *result;
    List       *subps;
    ListCell   *l;
 
    /*
     * do nothing when we get to the end of a leaf on tree.
     */
    if (node == NULL)
        return NULL;
 
    /*
     * Make sure there's enough stack available. Need to check here, in
     * addition to ExecProcNode() (via ExecProcNodeFirst()), to ensure the
     * stack isn't overrun while initializing the node tree.
     */
    check_stack_depth();
 
    switch (nodeTag(node))
    {
            /*
             * control nodes
             */
        case T_Result:
            result = (PlanState *) ExecInitResult((Result *) node,
                                                  estate, eflags);
            break;
 
        case T_ProjectSet:
            result = (PlanState *) ExecInitProjectSet((ProjectSet *) node,
                                                      estate, eflags);
            break;
 
        case T_ModifyTable:
            result = (PlanState *) ExecInitModifyTable((ModifyTable *) node,
                                                       estate, eflags);
            break;
 
        case T_Append:
            result = (PlanState *) ExecInitAppend((Append *) node,
                                                  estate, eflags);
            break;
 
        case T_MergeAppend:
            result = (PlanState *) ExecInitMergeAppend((MergeAppend *) node,
                                                       estate, eflags);
            break;
 
        case T_RecursiveUnion:
            result = (PlanState *) ExecInitRecursiveUnion((RecursiveUnion *) node,
                                                          estate, eflags);
            break;
 
        case T_BitmapAnd:
            result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node,
                                                     estate, eflags);
            break;
 
        case T_BitmapOr:
            result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node,
                                                    estate, eflags);
            break;
 
            /*
             * scan nodes
             */
        case T_SeqScan:
            result = (PlanState *) ExecInitSeqScan((SeqScan *) node,
                                                   estate, eflags);
            break;
 
        case T_SampleScan:
            result = (PlanState *) ExecInitSampleScan((SampleScan *) node,
                                                      estate, eflags);
            break;
 
        case T_IndexScan:
            result = (PlanState *) ExecInitIndexScan((IndexScan *) node,
                                                     estate, eflags);
            break;
 
        case T_IndexOnlyScan:
            result = (PlanState *) ExecInitIndexOnlyScan((IndexOnlyScan *) node,
                                                         estate, eflags);
            break;
 
        case T_BitmapIndexScan:
            result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node,
                                                           estate, eflags);
            break;
 
        case T_BitmapHeapScan:
            result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node,
                                                          estate, eflags);
            break;
 
        case T_TidScan:
            result = (PlanState *) ExecInitTidScan((TidScan *) node,
                                                   estate, eflags);
            break;
 
        case T_TidRangeScan:
            result = (PlanState *) ExecInitTidRangeScan((TidRangeScan *) node,
                                                        estate, eflags);
            break;
 
        case T_SubqueryScan:
            result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node,
                                                        estate, eflags);
            break;
 
        case T_FunctionScan:
            result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node,
                                                        estate, eflags);
            break;
 
        case T_TableFuncScan:
            result = (PlanState *) ExecInitTableFuncScan((TableFuncScan *) node,
                                                         estate, eflags);
            break;
 
        case T_ValuesScan:
            result = (PlanState *) ExecInitValuesScan((ValuesScan *) node,
                                                      estate, eflags);
            break;
 
        case T_CteScan:
            result = (PlanState *) ExecInitCteScan((CteScan *) node,
                                                   estate, eflags);
            break;
 
        case T_NamedTuplestoreScan:
            result = (PlanState *) ExecInitNamedTuplestoreScan((NamedTuplestoreScan *) node,
                                                               estate, eflags);
            break;
 
        case T_WorkTableScan:
            result = (PlanState *) ExecInitWorkTableScan((WorkTableScan *) node,
                                                         estate, eflags);
            break;
 
        case T_ForeignScan:
            result = (PlanState *) ExecInitForeignScan((ForeignScan *) node,
                                                       estate, eflags);
            break;
 
        case T_CustomScan:
            result = (PlanState *) ExecInitCustomScan((CustomScan *) node,
                                                      estate, eflags);
            break;
 
            /*
             * join nodes
             */
        case T_NestLoop:
            result = (PlanState *) ExecInitNestLoop((NestLoop *) node,
                                                    estate, eflags);
            break;
 
        case T_MergeJoin:
            result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node,
                                                     estate, eflags);
            break;
 
        case T_HashJoin:
            result = (PlanState *) ExecInitHashJoin((HashJoin *) node,
                                                    estate, eflags);
            break;
 
            /*
             * materialization nodes
             */
        case T_Material:
            result = (PlanState *) ExecInitMaterial((Material *) node,
                                                    estate, eflags);
            break;
 
        case T_Sort:
            result = (PlanState *) ExecInitSort((Sort *) node,
                                                estate, eflags);
            break;
 
        case T_IncrementalSort:
            result = (PlanState *) ExecInitIncrementalSort((IncrementalSort *) node,
                                                           estate, eflags);
            break;
 
        case T_Memoize:
            result = (PlanState *) ExecInitMemoize((Memoize *) node, estate,
                                                   eflags);
            break;
 
        case T_Group:
            result = (PlanState *) ExecInitGroup((Group *) node,
                                                 estate, eflags);
            break;
 
        case T_Agg:
            result = (PlanState *) ExecInitAgg((Agg *) node,
                                               estate, eflags);
            break;
 
        case T_WindowAgg:
            result = (PlanState *) ExecInitWindowAgg((WindowAgg *) node,
                                                     estate, eflags);
            break;
 
        case T_Unique:
            result = (PlanState *) ExecInitUnique((Unique *) node,
                                                  estate, eflags);
            break;
 
        case T_Gather:
            result = (PlanState *) ExecInitGather((Gather *) node,
                                                  estate, eflags);
            break;
 
        case T_GatherMerge:
            result = (PlanState *) ExecInitGatherMerge((GatherMerge *) node,
                                                       estate, eflags);
            break;
 
        case T_Hash:
            result = (PlanState *) ExecInitHash((Hash *) node,
                                                estate, eflags);
            break;
 
        case T_SetOp:
            result = (PlanState *) ExecInitSetOp((SetOp *) node,
                                                 estate, eflags);
            break;
 
        case T_LockRows:
            result = (PlanState *) ExecInitLockRows((LockRows *) node,
                                                    estate, eflags);
            break;
 
        case T_Limit:
            result = (PlanState *) ExecInitLimit((Limit *) node,
                                                 estate, eflags);
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
            result = NULL;      /* keep compiler quiet */
            break;
    }
 
    ExecSetExecProcNode(result, result->ExecProcNode);
 
    /*
     * Initialize any initPlans present in this node.  The planner put them in
     * a separate list for us.
     *
     * The defining characteristic of initplans is that they don't have
     * arguments, so we don't need to evaluate them (in contrast to
     * ExecInitSubPlanExpr()).
     */
    subps = NIL;
    foreach(l, node->initPlan)
    {
        SubPlan    *subplan = (SubPlan *) lfirst(l);
        SubPlanState *sstate;
 
        Assert(IsA(subplan, SubPlan));
        Assert(subplan->args == NIL);
        sstate = ExecInitSubPlan(subplan, result);
        subps = lappend(subps, sstate);
    }
    result->initPlan = subps;
 
    /* Set up instrumentation for this node if requested */
    if (estate->es_instrument)
        result->instrument = InstrAlloc(1, estate->es_instrument,
                                        result->async_capable);
 
    return result;
}

References SubPlan::args, Assert(), PlanState::async_capable, check_stack_depth(), elog, ERROR, EState::es_instrument, ExecInitAgg(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapHeapScan(), ExecInitBitmapIndexScan(), ExecInitBitmapOr(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubPlan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitValuesScan(), ExecInitWindowAgg(), ExecInitWorkTableScan(), PlanState::ExecProcNode, ExecSetExecProcNode(), PlanState::initPlan, Plan::initPlan, InstrAlloc(), PlanState::instrument, IsA, lappend(), lfirst, NIL, and nodeTag.

Referenced by EvalPlanQualStart(), ExecInitAgg(), ExecInitAppend(), ExecInitBitmapAnd(), ExecInitBitmapHeapScan(), ExecInitBitmapOr(), ExecInitForeignScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecInitWindowAgg(), and InitPlan().

◆ ExecInitNullTupleSlot()

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

Definition at line 2034 of file execTuples.c.

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

References ExecInitExtraTupleSlot(), and ExecStoreAllNullTuple().

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

◆ ExecInitQual()

ExprState * ExecInitQual	(	List *	qual,
		PlanState *	parent
	)

Definition at line 229 of file execExpr.c.

{
    ExprState  *state;
    ExprEvalStep scratch = {0};
    List       *adjust_jumps = NIL;
 
    /* short-circuit (here and in ExecQual) for empty restriction list */
    if (qual == NIL)
        return NULL;
 
    Assert(IsA(qual, List));
 
    state = makeNode(ExprState);
    state->expr = (Expr *) qual;
    state->parent = parent;
    state->ext_params = NULL;
 
    /* mark expression as to be used with ExecQual() */
    state->flags = EEO_FLAG_IS_QUAL;
 
    /* Insert setup steps as needed */
    ExecCreateExprSetupSteps(state, (Node *) qual);
 
    /*
     * ExecQual() needs to return false for an expression returning NULL. That
     * allows us to short-circuit the evaluation the first time a NULL is
     * encountered.  As qual evaluation is a hot-path this warrants using a
     * special opcode for qual evaluation that's simpler than BOOL_AND (which
     * has more complex NULL handling).
     */
    scratch.opcode = EEOP_QUAL;
 
    /*
     * We can use ExprState's resvalue/resnull as target for each qual expr.
     */
    scratch.resvalue = &state->resvalue;
    scratch.resnull = &state->resnull;
 
    foreach_ptr(Expr, node, qual)
    {
        /* first evaluate expression */
        ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
 
        /* then emit EEOP_QUAL to detect if it's false (or null) */
        scratch.d.qualexpr.jumpdone = -1;
        ExprEvalPushStep(state, &scratch);
        adjust_jumps = lappend_int(adjust_jumps,
                                   state->steps_len - 1);
    }
 
    /* adjust jump targets */
    foreach_int(jump, adjust_jumps)
    {
        ExprEvalStep *as = &state->steps[jump];
 
        Assert(as->opcode == EEOP_QUAL);
        Assert(as->d.qualexpr.jumpdone == -1);
        as->d.qualexpr.jumpdone = state->steps_len;
    }
 
    /*
     * At the end, we don't need to do anything more.  The last qual expr must
     * have yielded TRUE, and since its result is stored in the desired output
     * location, we're done.
     */
    scratch.opcode = EEOP_DONE_RETURN;
    ExprEvalPushStep(state, &scratch);
 
    ExecReadyExpr(state);
 
    return state;
}

References Assert(), ExprEvalStep::d, EEO_FLAG_IS_QUAL, EEOP_DONE_RETURN, EEOP_QUAL, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), ExprEvalPushStep(), foreach_int, foreach_ptr, IsA, ExprEvalStep::jumpdone, lappend_int(), makeNode, NIL, ExprEvalStep::opcode, ExprEvalStep::qualexpr, ExprEvalStep::resnull, and ExprEvalStep::resvalue.

Referenced by CopyFrom(), ExecInitAgg(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGroup(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitMerge(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitPartitionInfo(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitValuesScan(), ExecInitWindowAgg(), ExecInitWorkTableScan(), and ExecPrepareQual().

◆ ExecInitRangeTable()

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

Definition at line 775 of file execUtils.c.

{
    /* Remember the range table List as-is */
    estate->es_range_table = rangeTable;
 
    /* ... and the RTEPermissionInfo List too */
    estate->es_rteperminfos = permInfos;
 
    /* Set size of associated arrays */
    estate->es_range_table_size = list_length(rangeTable);
 
    /*
     * Initialize the bitmapset of RT indexes (es_unpruned_relids)
     * representing relations that will be scanned during execution. This set
     * is initially populated by the caller and may be extended later by
     * ExecDoInitialPruning() to include RT indexes of unpruned leaf
     * partitions.
     */
    estate->es_unpruned_relids = unpruned_relids;
 
    /*
     * Allocate an array to store an open Relation corresponding to each
     * rangetable entry, and initialize entries to NULL.  Relations are opened
     * and stored here as needed.
     */
    estate->es_relations = (Relation *)
        palloc0(estate->es_range_table_size * sizeof(Relation));
 
    /*
     * es_result_relations and es_rowmarks are also parallel to
     * es_range_table, but are allocated only if needed.
     */
    estate->es_result_relations = NULL;
    estate->es_rowmarks = NULL;
}

References EState::es_range_table, EState::es_range_table_size, EState::es_relations, EState::es_result_relations, EState::es_rowmarks, EState::es_rteperminfos, EState::es_unpruned_relids, list_length(), and palloc0().

Referenced by CopyFrom(), create_edata_for_relation(), create_estate_for_relation(), and InitPlan().

◆ ExecInitResultRelation()

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

Definition at line 882 of file execUtils.c.

{
    Relation    resultRelationDesc;
 
    resultRelationDesc = ExecGetRangeTableRelation(estate, rti, true);
    InitResultRelInfo(resultRelInfo,
                      resultRelationDesc,
                      rti,
                      NULL,
                      estate->es_instrument);
 
    if (estate->es_result_relations == NULL)
        estate->es_result_relations = (ResultRelInfo **)
            palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *));
    estate->es_result_relations[rti - 1] = resultRelInfo;
 
    /*
     * Saving in the list allows to avoid needlessly traversing the whole
     * array when only a few of its entries are possibly non-NULL.
     */
    estate->es_opened_result_relations =
        lappend(estate->es_opened_result_relations, resultRelInfo);
}

References EState::es_instrument, EState::es_opened_result_relations, EState::es_range_table_size, EState::es_result_relations, ExecGetRangeTableRelation(), InitResultRelInfo(), lappend(), and palloc0().

Referenced by CopyFrom(), and ExecInitModifyTable().

◆ ExecInitResultSlot()

void ExecInitResultSlot	(	PlanState *	planstate,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1966 of file execTuples.c.

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

References EState::es_tupleTable, ExecAllocTableSlot(), PlanState::ps_ResultTupleDesc, PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, and PlanState::state.

Referenced by ExecConditionalAssignProjectionInfo(), and ExecInitResultTupleSlotTL().

◆ ExecInitResultTupleSlotTL()

void ExecInitResultTupleSlotTL	(	PlanState *	planstate,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 1986 of file execTuples.c.

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

References ExecInitResultSlot(), and ExecInitResultTypeTL().

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

◆ ExecInitResultTypeTL()

void ExecInitResultTypeTL ( PlanState * planstate )

Definition at line 1942 of file execTuples.c.

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

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

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

◆ ExecInitScanTupleSlot()

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

Definition at line 1998 of file execTuples.c.

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

References EState::es_tupleTable, ExecAllocTableSlot(), ScanState::ps, PlanState::scandesc, PlanState::scanops, PlanState::scanopsfixed, PlanState::scanopsset, and ScanState::ss_ScanTupleSlot.

Referenced by ExecCreateScanSlotFromOuterPlan(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitNamedTuplestoreScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitValuesScan(), and ExecInitWorkTableScan().

◆ ExecInitTableFunctionResult()

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

Definition at line 56 of file execSRF.c.

{
    SetExprState *state = makeNode(SetExprState);
 
    state->funcReturnsSet = false;
    state->expr = expr;
    state->func.fn_oid = InvalidOid;
 
    /*
     * Normally the passed expression tree will be a FuncExpr, since the
     * grammar only allows a function call at the top level of a table
     * function reference.  However, if the function doesn't return set then
     * the planner might have replaced the function call via constant-folding
     * or inlining.  So if we see any other kind of expression node, execute
     * it via the general ExecEvalExpr() code.  That code path will not
     * support set-returning functions buried in the expression, though.
     */
    if (IsA(expr, FuncExpr))
    {
        FuncExpr   *func = (FuncExpr *) expr;
 
        state->funcReturnsSet = func->funcretset;
        state->args = ExecInitExprList(func->args, parent);
 
        init_sexpr(func->funcid, func->inputcollid, expr, state, parent,
                   econtext->ecxt_per_query_memory, func->funcretset, false);
    }
    else
    {
        state->elidedFuncState = ExecInitExpr(expr, parent);
    }
 
    return state;
}

References FuncExpr::args, ExprContext::ecxt_per_query_memory, ExecInitExpr(), ExecInitExprList(), FuncExpr::funcid, init_sexpr(), InvalidOid, IsA, and makeNode.

Referenced by ExecInitFunctionScan().

◆ ExecInsertIndexTuples()

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

Definition at line 310 of file execIndexing.c.

{
    ItemPointer tupleid = &slot->tts_tid;
    List       *result = NIL;
    int         i;
    int         numIndices;
    RelationPtr relationDescs;
    Relation    heapRelation;
    IndexInfo **indexInfoArray;
    ExprContext *econtext;
    Datum       values[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
 
    Assert(ItemPointerIsValid(tupleid));
 
    /*
     * Get information from the result relation info structure.
     */
    numIndices = resultRelInfo->ri_NumIndices;
    relationDescs = resultRelInfo->ri_IndexRelationDescs;
    indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
    heapRelation = resultRelInfo->ri_RelationDesc;
 
    /* Sanity check: slot must belong to the same rel as the resultRelInfo. */
    Assert(slot->tts_tableOid == RelationGetRelid(heapRelation));
 
    /*
     * 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 and insert the index tuple
     */
    for (i = 0; i < numIndices; i++)
    {
        Relation    indexRelation = relationDescs[i];
        IndexInfo  *indexInfo;
        bool        applyNoDupErr;
        IndexUniqueCheck checkUnique;
        bool        indexUnchanged;
        bool        satisfiesConstraint;
 
        if (indexRelation == NULL)
            continue;
 
        indexInfo = indexInfoArray[i];
 
        /* If the index is marked as read-only, ignore it */
        if (!indexInfo->ii_ReadyForInserts)
            continue;
 
        /*
         * Skip processing of non-summarizing indexes if we only update
         * summarizing indexes
         */
        if (onlySummarizing && !indexInfo->ii_Summarizing)
            continue;
 
        /* 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);
 
        /* Check whether to apply noDupErr to this index */
        applyNoDupErr = noDupErr &&
            (arbiterIndexes == NIL ||
             list_member_oid(arbiterIndexes,
                             indexRelation->rd_index->indexrelid));
 
        /*
         * The index AM does the actual insertion, plus uniqueness checking.
         *
         * For an immediate-mode unique index, we just tell the index AM to
         * throw error if not unique.
         *
         * For a deferrable unique index, we tell the index AM to just detect
         * possible non-uniqueness, and we add the index OID to the result
         * list if further checking is needed.
         *
         * For a speculative insertion (used by INSERT ... ON CONFLICT), do
         * the same as for a deferrable unique index.
         */
        if (!indexRelation->rd_index->indisunique)
            checkUnique = UNIQUE_CHECK_NO;
        else if (applyNoDupErr)
            checkUnique = UNIQUE_CHECK_PARTIAL;
        else if (indexRelation->rd_index->indimmediate)
            checkUnique = UNIQUE_CHECK_YES;
        else
            checkUnique = UNIQUE_CHECK_PARTIAL;
 
        /*
         * There's definitely going to be an index_insert() call for this
         * index.  If we're being called as part of an UPDATE statement,
         * consider if the 'indexUnchanged' = true hint should be passed.
         */
        indexUnchanged = update && index_unchanged_by_update(resultRelInfo,
                                                             estate,
                                                             indexInfo,
                                                             indexRelation);
 
        satisfiesConstraint =
            index_insert(indexRelation, /* index relation */
                         values,    /* array of index Datums */
                         isnull,    /* null flags */
                         tupleid,   /* tid of heap tuple */
                         heapRelation,  /* heap relation */
                         checkUnique,   /* type of uniqueness check to do */
                         indexUnchanged,    /* UPDATE without logical change? */
                         indexInfo);    /* index AM may need this */
 
        /*
         * If the index has an associated exclusion constraint, check that.
         * This is simpler than the process for uniqueness checks since we
         * always insert first and then check.  If the constraint is deferred,
         * we check now anyway, but don't throw error on violation or wait for
         * a conclusive outcome from a concurrent insertion; instead we'll
         * queue a recheck event.  Similarly, noDupErr callers (speculative
         * inserters) will recheck later, and wait for a conclusive outcome
         * then.
         *
         * An index for an exclusion constraint can't also be UNIQUE (not an
         * essential property, we just don't allow it in the grammar), so no
         * need to preserve the prior state of satisfiesConstraint.
         */
        if (indexInfo->ii_ExclusionOps != NULL)
        {
            bool        violationOK;
            CEOUC_WAIT_MODE waitMode;
 
            if (applyNoDupErr)
            {
                violationOK = true;
                waitMode = CEOUC_LIVELOCK_PREVENTING_WAIT;
            }
            else if (!indexRelation->rd_index->indimmediate)
            {
                violationOK = true;
                waitMode = CEOUC_NOWAIT;
            }
            else
            {
                violationOK = false;
                waitMode = CEOUC_WAIT;
            }
 
            satisfiesConstraint =
                check_exclusion_or_unique_constraint(heapRelation,
                                                     indexRelation, indexInfo,
                                                     tupleid, values, isnull,
                                                     estate, false,
                                                     waitMode, violationOK, NULL);
        }
 
        if ((checkUnique == UNIQUE_CHECK_PARTIAL ||
             indexInfo->ii_ExclusionOps != NULL) &&
            !satisfiesConstraint)
        {
            /*
             * The tuple potentially violates the uniqueness or exclusion
             * constraint, so make a note of the index so that we can re-check
             * it later.  Speculative inserters are told if there was a
             * speculative conflict, since that always requires a restart.
             */
            result = lappend_oid(result, RelationGetRelid(indexRelation));
            if (indexRelation->rd_index->indimmediate && specConflict)
                *specConflict = true;
        }
    }
 
    return result;
}

References Assert(), CEOUC_LIVELOCK_PREVENTING_WAIT, CEOUC_NOWAIT, CEOUC_WAIT, check_exclusion_or_unique_constraint(), ExprContext::ecxt_scantuple, ExecPrepareQual(), ExecQual(), FormIndexDatum(), GetPerTupleExprContext, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_ReadyForInserts, IndexInfo::ii_Summarizing, index_insert(), INDEX_MAX_KEYS, index_unchanged_by_update(), ItemPointerIsValid(), lappend_oid(), list_member_oid(), NIL, RelationData::rd_index, RelationGetRelid, ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tid, UNIQUE_CHECK_NO, UNIQUE_CHECK_PARTIAL, UNIQUE_CHECK_YES, and values.

Referenced by CopyFrom(), CopyMultiInsertBufferFlush(), ExecInsert(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), and ExecUpdateEpilogue().

◆ ExecLookupResultRelByOid()

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

Definition at line 4420 of file nodeModifyTable.c.

{
    if (node->mt_resultOidHash)
    {
        /* Use the pre-built hash table to locate the rel */
        MTTargetRelLookup *mtlookup;
 
        mtlookup = (MTTargetRelLookup *)
            hash_search(node->mt_resultOidHash, &resultoid, HASH_FIND, NULL);
        if (mtlookup)
        {
            if (update_cache)
            {
                node->mt_lastResultOid = resultoid;
                node->mt_lastResultIndex = mtlookup->relationIndex;
            }
            return node->resultRelInfo + mtlookup->relationIndex;
        }
    }
    else
    {
        /* With few target rels, just search the ResultRelInfo array */
        for (int ndx = 0; ndx < node->mt_nrels; ndx++)
        {
            ResultRelInfo *rInfo = node->resultRelInfo + ndx;
 
            if (RelationGetRelid(rInfo->ri_RelationDesc) == resultoid)
            {
                if (update_cache)
                {
                    node->mt_lastResultOid = resultoid;
                    node->mt_lastResultIndex = ndx;
                }
                return rInfo;
            }
        }
    }
 
    if (!missing_ok)
        elog(ERROR, "incorrect result relation OID %u", resultoid);
    return NULL;
}

References elog, ERROR, HASH_FIND, hash_search(), ModifyTableState::mt_lastResultIndex, ModifyTableState::mt_lastResultOid, ModifyTableState::mt_nrels, ModifyTableState::mt_resultOidHash, RelationGetRelid, MTTargetRelLookup::relationIndex, ModifyTableState::resultRelInfo, and ResultRelInfo::ri_RelationDesc.

Referenced by ExecFindPartition(), and ExecModifyTable().

◆ ExecMakeFunctionResultSet()

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

Definition at line 497 of file execSRF.c.

{
    List       *arguments;
    Datum       result;
    FunctionCallInfo fcinfo;
    PgStat_FunctionCallUsage fcusage;
    ReturnSetInfo rsinfo;
    bool        callit;
    int         i;
 
restart:
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    /*
     * If a previous call of the function returned a set result in the form of
     * a tuplestore, continue reading rows from the tuplestore until it's
     * empty.
     */
    if (fcache->funcResultStore)
    {
        TupleTableSlot *slot = fcache->funcResultSlot;
        MemoryContext oldContext;
        bool        foundTup;
 
        /*
         * Have to make sure tuple in slot lives long enough, otherwise
         * clearing the slot could end up trying to free something already
         * freed.
         */
        oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
        foundTup = tuplestore_gettupleslot(fcache->funcResultStore, true, false,
                                           fcache->funcResultSlot);
        MemoryContextSwitchTo(oldContext);
 
        if (foundTup)
        {
            *isDone = ExprMultipleResult;
            if (fcache->funcReturnsTuple)
            {
                /* We must return the whole tuple as a Datum. */
                *isNull = false;
                return ExecFetchSlotHeapTupleDatum(fcache->funcResultSlot);
            }
            else
            {
                /* Extract the first column and return it as a scalar. */
                return slot_getattr(fcache->funcResultSlot, 1, isNull);
            }
        }
        /* Exhausted the tuplestore, so clean up */
        tuplestore_end(fcache->funcResultStore);
        fcache->funcResultStore = NULL;
        *isDone = ExprEndResult;
        *isNull = true;
        return (Datum) 0;
    }
 
    /*
     * arguments is a list of expressions to evaluate before passing to the
     * function manager.  We skip the evaluation if it was already done in the
     * previous call (ie, we are continuing the evaluation of a set-valued
     * function).  Otherwise, collect the current argument values into fcinfo.
     *
     * The arguments have to live in a context that lives at least until all
     * rows from this SRF have been returned, otherwise ValuePerCall SRFs
     * would reference freed memory after the first returned row.
     */
    fcinfo = fcache->fcinfo;
    arguments = fcache->args;
    if (!fcache->setArgsValid)
    {
        MemoryContext oldContext = MemoryContextSwitchTo(argContext);
 
        ExecEvalFuncArgs(fcinfo, arguments, econtext);
        MemoryContextSwitchTo(oldContext);
    }
    else
    {
        /* Reset flag (we may set it again below) */
        fcache->setArgsValid = false;
    }
 
    /*
     * Now call the function, passing the evaluated parameter values.
     */
 
    /* Prepare a resultinfo node for communication. */
    fcinfo->resultinfo = (Node *) &rsinfo;
    rsinfo.type = T_ReturnSetInfo;
    rsinfo.econtext = econtext;
    rsinfo.expectedDesc = fcache->funcResultDesc;
    rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize);
    /* note we do not set SFRM_Materialize_Random or _Preferred */
    rsinfo.returnMode = SFRM_ValuePerCall;
    /* isDone is filled below */
    rsinfo.setResult = NULL;
    rsinfo.setDesc = NULL;
 
    /*
     * If function is strict, and there are any NULL arguments, skip calling
     * the function.
     */
    callit = true;
    if (fcache->func.fn_strict)
    {
        for (i = 0; i < fcinfo->nargs; i++)
        {
            if (fcinfo->args[i].isnull)
            {
                callit = false;
                break;
            }
        }
    }
 
    if (callit)
    {
        pgstat_init_function_usage(fcinfo, &fcusage);
 
        fcinfo->isnull = false;
        rsinfo.isDone = ExprSingleResult;
        result = FunctionCallInvoke(fcinfo);
        *isNull = fcinfo->isnull;
        *isDone = rsinfo.isDone;
 
        pgstat_end_function_usage(&fcusage,
                                  rsinfo.isDone != ExprMultipleResult);
    }
    else
    {
        /* for a strict SRF, result for NULL is an empty set */
        result = (Datum) 0;
        *isNull = true;
        *isDone = ExprEndResult;
    }
 
    /* Which protocol does function want to use? */
    if (rsinfo.returnMode == SFRM_ValuePerCall)
    {
        if (*isDone != ExprEndResult)
        {
            /*
             * Save the current argument values to re-use on the next call.
             */
            if (*isDone == ExprMultipleResult)
            {
                fcache->setArgsValid = true;
                /* Register cleanup callback if we didn't already */
                if (!fcache->shutdown_reg)
                {
                    RegisterExprContextCallback(econtext,
                                                ShutdownSetExpr,
                                                PointerGetDatum(fcache));
                    fcache->shutdown_reg = true;
                }
            }
        }
    }
    else if (rsinfo.returnMode == SFRM_Materialize)
    {
        /* check we're on the same page as the function author */
        if (rsinfo.isDone != ExprSingleResult)
            ereport(ERROR,
                    (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                     errmsg("table-function protocol for materialize mode was not followed")));
        if (rsinfo.setResult != NULL)
        {
            /* prepare to return values from the tuplestore */
            ExecPrepareTuplestoreResult(fcache, econtext,
                                        rsinfo.setResult,
                                        rsinfo.setDesc);
            /* loop back to top to start returning from tuplestore */
            goto restart;
        }
        /* if setResult was left null, treat it as empty set */
        *isDone = ExprEndResult;
        *isNull = true;
        result = (Datum) 0;
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                 errmsg("unrecognized table-function returnMode: %d",
                        (int) rsinfo.returnMode)));
 
    return result;
}

References ReturnSetInfo::allowedModes, FunctionCallInfoBaseData::args, SetExprState::args, check_stack_depth(), ReturnSetInfo::econtext, ereport, errcode(), errmsg(), ERROR, ExecEvalFuncArgs(), ExecFetchSlotHeapTupleDatum(), ExecPrepareTuplestoreResult(), ReturnSetInfo::expectedDesc, ExprEndResult, ExprMultipleResult, ExprSingleResult, SetExprState::fcinfo, FmgrInfo::fn_strict, SetExprState::func, SetExprState::funcResultDesc, SetExprState::funcResultSlot, SetExprState::funcResultStore, SetExprState::funcReturnsTuple, FunctionCallInvoke, i, ReturnSetInfo::isDone, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, MemoryContextSwitchTo(), FunctionCallInfoBaseData::nargs, pgstat_end_function_usage(), pgstat_init_function_usage(), PointerGetDatum(), RegisterExprContextCallback(), FunctionCallInfoBaseData::resultinfo, ReturnSetInfo::returnMode, SetExprState::setArgsValid, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_ValuePerCall, SetExprState::shutdown_reg, ShutdownSetExpr(), slot_getattr(), TupleTableSlot::tts_mcxt, tuplestore_end(), tuplestore_gettupleslot(), and ReturnSetInfo::type.

Referenced by ExecProjectSRF().

◆ ExecMakeTableFunctionResult()

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

Definition at line 101 of file execSRF.c.

{
    Tuplestorestate *tupstore = NULL;
    TupleDesc   tupdesc = NULL;
    Oid         funcrettype;
    bool        returnsTuple;
    bool        returnsSet = false;
    FunctionCallInfo fcinfo;
    PgStat_FunctionCallUsage fcusage;
    ReturnSetInfo rsinfo;
    HeapTupleData tmptup;
    MemoryContext callerContext;
    bool        first_time = true;
 
    /*
     * Execute per-tablefunc actions in appropriate context.
     *
     * The FunctionCallInfo needs to live across all the calls to a
     * ValuePerCall function, so it can't be allocated in the per-tuple
     * context. Similarly, the function arguments need to be evaluated in a
     * context that is longer lived than the per-tuple context: The argument
     * values would otherwise disappear when we reset that context in the
     * inner loop.  As the caller's CurrentMemoryContext is typically a
     * query-lifespan context, we don't want to leak memory there.  We require
     * the caller to pass a separate memory context that can be used for this,
     * and can be reset each time through to avoid bloat.
     */
    MemoryContextReset(argContext);
    callerContext = MemoryContextSwitchTo(argContext);
 
    funcrettype = exprType((Node *) setexpr->expr);
 
    returnsTuple = type_is_rowtype(funcrettype);
 
    /*
     * Prepare a resultinfo node for communication.  We always do this even if
     * not expecting a set result, so that we can pass expectedDesc.  In the
     * generic-expression case, the expression doesn't actually get to see the
     * resultinfo, but set it up anyway because we use some of the fields as
     * our own state variables.
     */
    rsinfo.type = T_ReturnSetInfo;
    rsinfo.econtext = econtext;
    rsinfo.expectedDesc = expectedDesc;
    rsinfo.allowedModes = (int) (SFRM_ValuePerCall | SFRM_Materialize | SFRM_Materialize_Preferred);
    if (randomAccess)
        rsinfo.allowedModes |= (int) SFRM_Materialize_Random;
    rsinfo.returnMode = SFRM_ValuePerCall;
    /* isDone is filled below */
    rsinfo.setResult = NULL;
    rsinfo.setDesc = NULL;
 
    fcinfo = palloc(SizeForFunctionCallInfo(list_length(setexpr->args)));
 
    /*
     * Normally the passed expression tree will be a SetExprState, since the
     * grammar only allows a function call at the top level of a table
     * function reference.  However, if the function doesn't return set then
     * the planner might have replaced the function call via constant-folding
     * or inlining.  So if we see any other kind of expression node, execute
     * it via the general ExecEvalExpr() code; the only difference is that we
     * don't get a chance to pass a special ReturnSetInfo to any functions
     * buried in the expression.
     */
    if (!setexpr->elidedFuncState)
    {
        /*
         * This path is similar to ExecMakeFunctionResultSet.
         */
        returnsSet = setexpr->funcReturnsSet;
        InitFunctionCallInfoData(*fcinfo, &(setexpr->func),
                                 list_length(setexpr->args),
                                 setexpr->fcinfo->fncollation,
                                 NULL, (Node *) &rsinfo);
        /* evaluate the function's argument list */
        Assert(CurrentMemoryContext == argContext);
        ExecEvalFuncArgs(fcinfo, setexpr->args, econtext);
 
        /*
         * If function is strict, and there are any NULL arguments, skip
         * calling the function and act like it returned NULL (or an empty
         * set, in the returns-set case).
         */
        if (setexpr->func.fn_strict)
        {
            int         i;
 
            for (i = 0; i < fcinfo->nargs; i++)
            {
                if (fcinfo->args[i].isnull)
                    goto no_function_result;
            }
        }
    }
    else
    {
        /* Treat setexpr as a generic expression */
        InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
    }
 
    /*
     * Switch to short-lived context for calling the function or expression.
     */
    MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
    /*
     * Loop to handle the ValuePerCall protocol (which is also the same
     * behavior needed in the generic ExecEvalExpr path).
     */
    for (;;)
    {
        Datum       result;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Reset per-tuple memory context before each call of the function or
         * expression. This cleans up any local memory the function may leak
         * when called.
         */
        ResetExprContext(econtext);
 
        /* Call the function or expression one time */
        if (!setexpr->elidedFuncState)
        {
            pgstat_init_function_usage(fcinfo, &fcusage);
 
            fcinfo->isnull = false;
            rsinfo.isDone = ExprSingleResult;
            result = FunctionCallInvoke(fcinfo);
 
            pgstat_end_function_usage(&fcusage,
                                      rsinfo.isDone != ExprMultipleResult);
        }
        else
        {
            result =
                ExecEvalExpr(setexpr->elidedFuncState, econtext, &fcinfo->isnull);
            rsinfo.isDone = ExprSingleResult;
        }
 
        /* Which protocol does function want to use? */
        if (rsinfo.returnMode == SFRM_ValuePerCall)
        {
            /*
             * Check for end of result set.
             */
            if (rsinfo.isDone == ExprEndResult)
                break;
 
            /*
             * If first time through, build tuplestore for result.  For a
             * scalar function result type, also make a suitable tupdesc.
             */
            if (first_time)
            {
                MemoryContext oldcontext =
                    MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
                tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
                rsinfo.setResult = tupstore;
                if (!returnsTuple)
                {
                    tupdesc = CreateTemplateTupleDesc(1);
                    TupleDescInitEntry(tupdesc,
                                       (AttrNumber) 1,
                                       "column",
                                       funcrettype,
                                       -1,
                                       0);
                    rsinfo.setDesc = tupdesc;
                }
                MemoryContextSwitchTo(oldcontext);
            }
 
            /*
             * Store current resultset item.
             */
            if (returnsTuple)
            {
                if (!fcinfo->isnull)
                {
                    HeapTupleHeader td = DatumGetHeapTupleHeader(result);
 
                    if (tupdesc == NULL)
                    {
                        MemoryContext oldcontext =
                            MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
                        /*
                         * This is the first non-NULL result from the
                         * function.  Use the type info embedded in the
                         * rowtype Datum to look up the needed tupdesc.  Make
                         * a copy for the query.
                         */
                        tupdesc = lookup_rowtype_tupdesc_copy(HeapTupleHeaderGetTypeId(td),
                                                              HeapTupleHeaderGetTypMod(td));
                        rsinfo.setDesc = tupdesc;
                        MemoryContextSwitchTo(oldcontext);
                    }
                    else
                    {
                        /*
                         * Verify all later returned rows have same subtype;
                         * necessary in case the type is RECORD.
                         */
                        if (HeapTupleHeaderGetTypeId(td) != tupdesc->tdtypeid ||
                            HeapTupleHeaderGetTypMod(td) != tupdesc->tdtypmod)
                            ereport(ERROR,
                                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                                     errmsg("rows returned by function are not all of the same row type")));
                    }
 
                    /*
                     * tuplestore_puttuple needs a HeapTuple not a bare
                     * HeapTupleHeader, but it doesn't need all the fields.
                     */
                    tmptup.t_len = HeapTupleHeaderGetDatumLength(td);
                    tmptup.t_data = td;
 
                    tuplestore_puttuple(tupstore, &tmptup);
                }
                else
                {
                    /*
                     * NULL result from a tuple-returning function; expand it
                     * to a row of all nulls.  We rely on the expectedDesc to
                     * form such rows.  (Note: this would be problematic if
                     * tuplestore_putvalues saved the tdtypeid/tdtypmod from
                     * the provided descriptor, since that might not match
                     * what we get from the function itself.  But it doesn't.)
                     */
                    int         natts = expectedDesc->natts;
                    bool       *nullflags;
 
                    nullflags = (bool *) palloc(natts * sizeof(bool));
                    memset(nullflags, true, natts * sizeof(bool));
                    tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
                }
            }
            else
            {
                /* Scalar-type case: just store the function result */
                tuplestore_putvalues(tupstore, tupdesc, &result, &fcinfo->isnull);
            }
 
            /*
             * Are we done?
             */
            if (rsinfo.isDone != ExprMultipleResult)
                break;
 
            /*
             * Check that set-returning functions were properly declared.
             * (Note: for historical reasons, we don't complain if a non-SRF
             * returns ExprEndResult; that's treated as returning NULL.)
             */
            if (!returnsSet)
                ereport(ERROR,
                        (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                         errmsg("table-function protocol for value-per-call mode was not followed")));
        }
        else if (rsinfo.returnMode == SFRM_Materialize)
        {
            /* check we're on the same page as the function author */
            if (!first_time || rsinfo.isDone != ExprSingleResult || !returnsSet)
                ereport(ERROR,
                        (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                         errmsg("table-function protocol for materialize mode was not followed")));
            /* Done evaluating the set result */
            break;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
                     errmsg("unrecognized table-function returnMode: %d",
                            (int) rsinfo.returnMode)));
 
        first_time = false;
    }
 
no_function_result:
 
    /*
     * If we got nothing from the function (ie, an empty-set or NULL result),
     * we have to create the tuplestore to return, and if it's a
     * non-set-returning function then insert a single all-nulls row.  As
     * above, we depend on the expectedDesc to manufacture the dummy row.
     */
    if (rsinfo.setResult == NULL)
    {
        MemoryContext oldcontext =
            MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
        tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
        rsinfo.setResult = tupstore;
        MemoryContextSwitchTo(oldcontext);
 
        if (!returnsSet)
        {
            int         natts = expectedDesc->natts;
            bool       *nullflags;
 
            nullflags = (bool *) palloc(natts * sizeof(bool));
            memset(nullflags, true, natts * sizeof(bool));
            tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
        }
    }
 
    /*
     * If function provided a tupdesc, cross-check it.  We only really need to
     * do this for functions returning RECORD, but might as well do it always.
     */
    if (rsinfo.setDesc)
    {
        tupledesc_match(expectedDesc, rsinfo.setDesc);
 
        /*
         * If it is a dynamically-allocated TupleDesc, free it: it is
         * typically allocated in a per-query context, so we must avoid
         * leaking it across multiple usages.
         */
        if (rsinfo.setDesc->tdrefcount == -1)
            FreeTupleDesc(rsinfo.setDesc);
    }
 
    MemoryContextSwitchTo(callerContext);
 
    /* All done, pass back the tuplestore */
    return rsinfo.setResult;
}

References ReturnSetInfo::allowedModes, FunctionCallInfoBaseData::args, SetExprState::args, Assert(), CHECK_FOR_INTERRUPTS, CreateTemplateTupleDesc(), CurrentMemoryContext, DatumGetHeapTupleHeader, ReturnSetInfo::econtext, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_per_tuple_memory, SetExprState::elidedFuncState, ereport, errcode(), errmsg(), ERROR, ExecEvalExpr(), ExecEvalFuncArgs(), ReturnSetInfo::expectedDesc, SetExprState::expr, ExprEndResult, ExprMultipleResult, ExprSingleResult, exprType(), SetExprState::fcinfo, FmgrInfo::fn_strict, FunctionCallInfoBaseData::fncollation, FreeTupleDesc(), SetExprState::func, SetExprState::funcReturnsSet, FunctionCallInvoke, HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), i, InitFunctionCallInfoData, InvalidOid, ReturnSetInfo::isDone, FunctionCallInfoBaseData::isnull, NullableDatum::isnull, list_length(), lookup_rowtype_tupdesc_copy(), MemoryContextReset(), MemoryContextSwitchTo(), FunctionCallInfoBaseData::nargs, TupleDescData::natts, palloc(), pgstat_end_function_usage(), pgstat_init_function_usage(), ResetExprContext, ReturnSetInfo::returnMode, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, SFRM_Materialize, SFRM_Materialize_Preferred, SFRM_Materialize_Random, SFRM_ValuePerCall, SizeForFunctionCallInfo, HeapTupleData::t_data, HeapTupleData::t_len, TupleDescData::tdrefcount, TupleDescData::tdtypeid, TupleDescData::tdtypmod, tupledesc_match(), TupleDescInitEntry(), tuplestore_begin_heap(), tuplestore_puttuple(), tuplestore_putvalues(), ReturnSetInfo::type, type_is_rowtype(), and work_mem.

Referenced by FunctionNext().

◆ ExecMarkPos()

void ExecMarkPos ( PlanState * node )

Definition at line 327 of file execAmi.c.

{
    switch (nodeTag(node))
    {
        case T_IndexScanState:
            ExecIndexMarkPos((IndexScanState *) node);
            break;
 
        case T_IndexOnlyScanState:
            ExecIndexOnlyMarkPos((IndexOnlyScanState *) node);
            break;
 
        case T_CustomScanState:
            ExecCustomMarkPos((CustomScanState *) node);
            break;
 
        case T_MaterialState:
            ExecMaterialMarkPos((MaterialState *) node);
            break;
 
        case T_SortState:
            ExecSortMarkPos((SortState *) node);
            break;
 
        case T_ResultState:
            ExecResultMarkPos((ResultState *) node);
            break;
 
        default:
            /* don't make hard error unless caller asks to restore... */
            elog(DEBUG2, "unrecognized node type: %d", (int) nodeTag(node));
            break;
    }
}

References DEBUG2, elog, ExecCustomMarkPos(), ExecIndexMarkPos(), ExecIndexOnlyMarkPos(), ExecMaterialMarkPos(), ExecResultMarkPos(), ExecSortMarkPos(), and nodeTag.

Referenced by ExecMergeJoin(), and ExecResultMarkPos().

◆ ExecMaterializesOutput()

bool ExecMaterializesOutput ( NodeTag plantype )

Definition at line 636 of file execAmi.c.

{
    switch (plantype)
    {
        case T_Material:
        case T_FunctionScan:
        case T_TableFuncScan:
        case T_CteScan:
        case T_NamedTuplestoreScan:
        case T_WorkTableScan:
        case T_Sort:
            return true;
 
        default:
            break;
    }
 
    return false;
}

Referenced by build_subplan(), consider_parallel_nestloop(), cost_subplan(), and match_unsorted_outer().

◆ ExecOpenIndices()

void ExecOpenIndices	(	ResultRelInfo *	resultRelInfo,
		bool	speculative
	)

Definition at line 160 of file execIndexing.c.

{
    Relation    resultRelation = resultRelInfo->ri_RelationDesc;
    List       *indexoidlist;
    ListCell   *l;
    int         len,
                i;
    RelationPtr relationDescs;
    IndexInfo **indexInfoArray;
 
    resultRelInfo->ri_NumIndices = 0;
 
    /* fast path if no indexes */
    if (!RelationGetForm(resultRelation)->relhasindex)
        return;
 
    /*
     * Get cached list of index OIDs
     */
    indexoidlist = RelationGetIndexList(resultRelation);
    len = list_length(indexoidlist);
    if (len == 0)
        return;
 
    /* This Assert will fail if ExecOpenIndices is called twice */
    Assert(resultRelInfo->ri_IndexRelationDescs == NULL);
 
    /*
     * allocate space for result arrays
     */
    relationDescs = (RelationPtr) palloc(len * sizeof(Relation));
    indexInfoArray = (IndexInfo **) palloc(len * sizeof(IndexInfo *));
 
    resultRelInfo->ri_NumIndices = len;
    resultRelInfo->ri_IndexRelationDescs = relationDescs;
    resultRelInfo->ri_IndexRelationInfo = indexInfoArray;
 
    /*
     * For each index, open the index relation and save pg_index info. We
     * acquire RowExclusiveLock, signifying we will update the index.
     *
     * Note: we do this even if the index is not indisready; it's not worth
     * the trouble to optimize for the case where it isn't.
     */
    i = 0;
    foreach(l, indexoidlist)
    {
        Oid         indexOid = lfirst_oid(l);
        Relation    indexDesc;
        IndexInfo  *ii;
 
        indexDesc = index_open(indexOid, RowExclusiveLock);
 
        /* extract index key information from the index's pg_index info */
        ii = BuildIndexInfo(indexDesc);
 
        /*
         * If the indexes are to be used for speculative insertion or conflict
         * detection in logical replication, add extra information required by
         * unique index entries.
         */
        if (speculative && ii->ii_Unique && !indexDesc->rd_index->indisexclusion)
            BuildSpeculativeIndexInfo(indexDesc, ii);
 
        relationDescs[i] = indexDesc;
        indexInfoArray[i] = ii;
        i++;
    }
 
    list_free(indexoidlist);
}

References Assert(), BuildIndexInfo(), BuildSpeculativeIndexInfo(), i, IndexInfo::ii_Unique, index_open(), len, lfirst_oid, list_free(), list_length(), palloc(), RelationData::rd_index, RelationGetForm, RelationGetIndexList(), ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_RelationDesc, and RowExclusiveLock.

Referenced by apply_handle_delete(), apply_handle_insert(), apply_handle_update_internal(), CatalogOpenIndexes(), CopyFrom(), ExecInitPartitionInfo(), ExecInsert(), and ExecUpdatePrologue().

◆ ExecOpenScanRelation()

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

Definition at line 744 of file execUtils.c.

{
    Relation    rel;
 
    /* Open the relation. */
    rel = ExecGetRangeTableRelation(estate, scanrelid, false);
 
    /*
     * Complain if we're attempting a scan of an unscannable relation, except
     * when the query won't actually be run.  This is a slightly klugy place
     * to do this, perhaps, but there is no better place.
     */
    if ((eflags & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA)) == 0 &&
        !RelationIsScannable(rel))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("materialized view \"%s\" has not been populated",
                        RelationGetRelationName(rel)),
                 errhint("Use the REFRESH MATERIALIZED VIEW command.")));
 
    return rel;
}

References ereport, errcode(), errhint(), errmsg(), ERROR, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_WITH_NO_DATA, ExecGetRangeTableRelation(), RelationGetRelationName, and RelationIsScannable.

Referenced by ExecInitBitmapHeapScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitTidRangeScan(), ExecInitTidScan(), and postgresBeginDirectModify().

◆ ExecPartitionCheck()

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

Definition at line 1930 of file execMain.c.

{
    ExprContext *econtext;
    bool        success;
 
    /*
     * If first time through, build expression state tree for the partition
     * check expression.  (In the corner case where the partition check
     * expression is empty, ie there's a default partition and nothing else,
     * we'll be fooled into executing this code each time through.  But it's
     * pretty darn cheap in that case, so we don't worry about it.)
     */
    if (resultRelInfo->ri_PartitionCheckExpr == NULL)
    {
        /*
         * Ensure that the qual tree and prepared expression are in the
         * query-lifespan context.
         */
        MemoryContext oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
        List       *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
 
        resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
        MemoryContextSwitchTo(oldcxt);
    }
 
    /*
     * We will use the EState's per-tuple context for evaluating constraint
     * 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;
 
    /*
     * As in case of the cataloged constraints, we treat a NULL result as
     * success here, not a failure.
     */
    success = ExecCheck(resultRelInfo->ri_PartitionCheckExpr, econtext);
 
    /* if asked to emit error, don't actually return on failure */
    if (!success && emitError)
        ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
 
    return success;
}

References ExprContext::ecxt_scantuple, EState::es_query_cxt, ExecCheck(), ExecPartitionCheckEmitError(), ExecPrepareCheck(), GetPerTupleExprContext, MemoryContextSwitchTo(), RelationGetPartitionQual(), ResultRelInfo::ri_PartitionCheckExpr, ResultRelInfo::ri_RelationDesc, and success.

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

◆ ExecPartitionCheckEmitError()

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

Definition at line 1983 of file execMain.c.

{
    Oid         root_relid;
    TupleDesc   tupdesc;
    char       *val_desc;
    Bitmapset  *modifiedCols;
 
    /*
     * 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 in the error message
     * matches the input tuple.
     */
    if (resultRelInfo->ri_RootResultRelInfo)
    {
        ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
        TupleDesc   old_tupdesc;
        AttrMap    *map;
 
        root_relid = RelationGetRelid(rootrel->ri_RelationDesc);
        tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
 
        old_tupdesc = RelationGetDescr(resultRelInfo->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));
    }
    else
    {
        root_relid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
        tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
        modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
                                 ExecGetUpdatedCols(resultRelInfo, estate));
    }
 
    val_desc = ExecBuildSlotValueDescription(root_relid,
                                             slot,
                                             tupdesc,
                                             modifiedCols,
                                             64);
    ereport(ERROR,
            (errcode(ERRCODE_CHECK_VIOLATION),
             errmsg("new row for relation \"%s\" violates partition constraint",
                    RelationGetRelationName(resultRelInfo->ri_RelationDesc)),
             val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
             errtable(resultRelInfo->ri_RelationDesc)));
}

References bms_union(), build_attrmap_by_name_if_req(), ereport, errcode(), errdetail(), errmsg(), ERROR, errtable(), ExecBuildSlotValueDescription(), ExecGetInsertedCols(), ExecGetUpdatedCols(), execute_attr_map_slot(), MakeTupleTableSlot(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, and TTSOpsVirtual.

Referenced by ExecCrossPartitionUpdate(), and ExecPartitionCheck().

◆ ExecPlanStillValid()

static bool ExecPlanStillValid ( EState * estate )

inlinestatic

Definition at line 270 of file executor.h.

{
    return estate->es_cachedplan == NULL ? true :
        CachedPlanValid(estate->es_cachedplan);
}

References CachedPlanValid(), EState::es_cachedplan, and true.

Referenced by ExecDoInitialPruning(), InitPlan(), and standard_ExecutorStart().

◆ ExecPrepareCheck()

ExprState * ExecPrepareCheck	(	List *	qual,
		EState *	estate
	)

Definition at line 816 of file execExpr.c.

{
    ExprState  *result;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    qual = (List *) expression_planner((Expr *) qual);
 
    result = ExecInitCheck(qual, NULL);
 
    MemoryContextSwitchTo(oldcontext);
 
    return result;
}

References EState::es_query_cxt, ExecInitCheck(), expression_planner(), and MemoryContextSwitchTo().

Referenced by ExecPartitionCheck().

◆ ExecPrepareExpr()

ExprState * ExecPrepareExpr	(	Expr *	node,
		EState *	estate
	)

Definition at line 765 of file execExpr.c.

{
    ExprState  *result;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    node = expression_planner(node);
 
    result = ExecInitExpr(node, NULL);
 
    MemoryContextSwitchTo(oldcontext);
 
    return result;
}

References EState::es_query_cxt, ExecInitExpr(), expression_planner(), and MemoryContextSwitchTo().

Referenced by ATExecAddColumn(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), ExecInitGenerated(), ExecPrepareExprList(), ExecRelCheck(), ExecuteCallStmt(), pgoutput_row_filter_init(), and validateDomainCheckConstraint().

◆ ExecPrepareExprList()

List * ExecPrepareExprList	(	List *	nodes,
		EState *	estate
	)

Definition at line 839 of file execExpr.c.

{
    List       *result = NIL;
    MemoryContext oldcontext;
    ListCell   *lc;
 
    /* Ensure that the list cell nodes are in the right context too */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    foreach(lc, nodes)
    {
        Expr       *e = (Expr *) lfirst(lc);
 
        result = lappend(result, ExecPrepareExpr(e, estate));
    }
 
    MemoryContextSwitchTo(oldcontext);
 
    return result;
}

References EState::es_query_cxt, ExecPrepareExpr(), lappend(), lfirst, MemoryContextSwitchTo(), and NIL.

Referenced by EvaluateParams(), FormIndexDatum(), FormPartitionKeyDatum(), and make_build_data().

◆ ExecPrepareQual()

ExprState * ExecPrepareQual	(	List *	qual,
		EState *	estate
	)

Definition at line 793 of file execExpr.c.

{
    ExprState  *result;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    qual = (List *) expression_planner((Expr *) qual);
 
    result = ExecInitQual(qual, NULL);
 
    MemoryContextSwitchTo(oldcontext);
 
    return result;
}

References EState::es_query_cxt, ExecInitQual(), expression_planner(), and MemoryContextSwitchTo().

Referenced by compute_index_stats(), ExecCheckIndexConstraints(), ExecInsertIndexTuples(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), and TriggerEnabled().

◆ ExecProcNode()

static TupleTableSlot * ExecProcNode ( PlanState * node )

inlinestatic

Definition at line 295 of file executor.h.

{
    if (node->chgParam != NULL) /* something changed? */
        ExecReScan(node);       /* let ReScan handle this */
 
    return node->ExecProcNode(node);
}

References PlanState::chgParam, PlanState::ExecProcNode, and ExecReScan().

Referenced by begin_partition(), buildSubPlanHash(), CteScanNext(), EvalPlanQualNext(), ExecAppend(), ExecGroup(), ExecHashJoinImpl(), ExecHashJoinOuterGetTuple(), ExecIncrementalSort(), ExecLimit(), ExecLockRows(), ExecMaterial(), ExecMemoize(), ExecMergeAppend(), ExecMergeJoin(), ExecModifyTable(), ExecNestLoop(), ExecParallelHashJoinOuterGetTuple(), ExecParallelHashJoinPartitionOuter(), ExecPostprocessPlan(), ExecProjectSet(), ExecRecursiveUnion(), ExecResult(), ExecScanSubPlan(), ExecSetParamPlan(), ExecSort(), ExecUnique(), ExecutePlan(), fetch_input_tuple(), gather_getnext(), gather_merge_readnext(), MultiExecParallelHash(), MultiExecPrivateHash(), postgresRecheckForeignScan(), setop_fill_hash_table(), setop_load_group(), setop_retrieve_sorted(), spool_tuples(), and SubqueryNext().

◆ ExecProject()

static TupleTableSlot * ExecProject ( ProjectionInfo * projInfo )

inlinestatic

Definition at line 464 of file executor.h.

{
    ExprContext *econtext = projInfo->pi_exprContext;
    ExprState  *state = &projInfo->pi_state;
    TupleTableSlot *slot = state->resultslot;
 
    /*
     * Clear any former contents of the result slot.  This makes it safe for
     * us to use the slot's Datum/isnull arrays as workspace.
     */
    ExecClearTuple(slot);
 
    /* Run the expression */
    ExecEvalExprNoReturnSwitchContext(state, econtext);
 
    /*
     * Successfully formed a result row.  Mark the result slot as containing a
     * valid virtual tuple (inlined version of ExecStoreVirtualTuple()).
     */
    slot->tts_flags &= ~TTS_FLAG_EMPTY;
    slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
 
    return slot;
}

References ExecClearTuple(), ExecEvalExprNoReturnSwitchContext(), TupleDescData::natts, ProjectionInfo::pi_exprContext, ProjectionInfo::pi_state, TupleTableSlot::tts_flags, TupleTableSlot::tts_nvalid, and TupleTableSlot::tts_tupleDescriptor.

Referenced by buildSubPlanHash(), ExecGather(), ExecGatherMerge(), ExecGetInsertNewTuple(), ExecGetUpdateNewTuple(), ExecGroup(), ExecHashJoinImpl(), ExecHashSubPlan(), ExecMergeJoin(), ExecMergeMatched(), ExecMergeNotMatched(), ExecNestLoop(), ExecOnConflictUpdate(), ExecProcessReturning(), ExecResult(), ExecScanExtended(), ExecWindowAgg(), MJFillInner(), MJFillOuter(), and project_aggregates().

◆ ExecQual()

static bool ExecQual	(	ExprState *	state,
		ExprContext *	econtext
	)

inlinestatic

Definition at line 500 of file executor.h.

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

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

Referenced by agg_retrieve_direct(), compute_index_stats(), CopyFrom(), ExecCheckIndexConstraints(), ExecEvalPreOrderedDistinctMulti(), ExecGroup(), ExecHashJoinImpl(), ExecInsertIndexTuples(), ExecMergeJoin(), ExecMergeMatched(), ExecMergeNotMatched(), ExecNestLoop(), ExecOnConflictUpdate(), ExecQualAndReset(), ExecResult(), ExecScanExtended(), ExecWindowAgg(), ExecWithCheckOptions(), ForeignRecheck(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), MemoizeHash_equal(), MJFillInner(), MJFillOuter(), process_ordered_aggregate_multi(), project_aggregates(), and TriggerEnabled().

◆ ExecQualAndReset()

static bool ExecQualAndReset	(	ExprState *	state,
		ExprContext *	econtext
	)

inlinestatic

Definition at line 527 of file executor.h.

{
    bool        ret = ExecQual(state, econtext);
 
    /* inline ResetExprContext, to avoid ordering issue in this file */
    MemoryContextReset(econtext->ecxt_per_tuple_memory);
    return ret;
}

References ExprContext::ecxt_per_tuple_memory, ExecQual(), and MemoryContextReset().

Referenced by agg_retrieve_direct(), are_peers(), BitmapHeapNext(), BitmapHeapRecheck(), ExecGroup(), ExecLimit(), ExecParallelScanHashBucket(), ExecScanHashBucket(), ExecUnique(), hypothetical_dense_rank_final(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), IndexRecheck(), spool_tuples(), and TupleHashTableMatch().

◆ ExecRelationIsTargetRelation()

bool ExecRelationIsTargetRelation	(	EState *	estate,
		Index	scanrelid
	)

Definition at line 731 of file execUtils.c.

{
    return list_member_int(estate->es_plannedstmt->resultRelations, scanrelid);
}

References EState::es_plannedstmt, list_member_int(), and PlannedStmt::resultRelations.

◆ ExecReScan()

void ExecReScan ( PlanState * node )

Definition at line 77 of file execAmi.c.

{
    /* If collecting timing stats, update them */
    if (node->instrument)
        InstrEndLoop(node->instrument);
 
    /*
     * If we have changed parameters, propagate that info.
     *
     * Note: ExecReScanSetParamPlan() can add bits to node->chgParam,
     * corresponding to the output param(s) that the InitPlan will update.
     * Since we make only one pass over the list, that means that an InitPlan
     * can depend on the output param(s) of a sibling InitPlan only if that
     * sibling appears earlier in the list.  This is workable for now given
     * the limited ways in which one InitPlan could depend on another, but
     * eventually we might need to work harder (or else make the planner
     * enlarge the extParam/allParam sets to include the params of depended-on
     * InitPlans).
     */
    if (node->chgParam != NULL)
    {
        ListCell   *l;
 
        foreach(l, node->initPlan)
        {
            SubPlanState *sstate = (SubPlanState *) lfirst(l);
            PlanState  *splan = sstate->planstate;
 
            if (splan->plan->extParam != NULL)  /* don't care about child
                                                 * local Params */
                UpdateChangedParamSet(splan, node->chgParam);
            if (splan->chgParam != NULL)
                ExecReScanSetParamPlan(sstate, node);
        }
        foreach(l, node->subPlan)
        {
            SubPlanState *sstate = (SubPlanState *) lfirst(l);
            PlanState  *splan = sstate->planstate;
 
            if (splan->plan->extParam != NULL)
                UpdateChangedParamSet(splan, node->chgParam);
        }
        /* Well. Now set chgParam for child trees. */
        if (outerPlanState(node) != NULL)
            UpdateChangedParamSet(outerPlanState(node), node->chgParam);
        if (innerPlanState(node) != NULL)
            UpdateChangedParamSet(innerPlanState(node), node->chgParam);
    }
 
    /* Call expression callbacks */
    if (node->ps_ExprContext)
        ReScanExprContext(node->ps_ExprContext);
 
    /* And do node-type-specific processing */
    switch (nodeTag(node))
    {
        case T_ResultState:
            ExecReScanResult((ResultState *) node);
            break;
 
        case T_ProjectSetState:
            ExecReScanProjectSet((ProjectSetState *) node);
            break;
 
        case T_ModifyTableState:
            ExecReScanModifyTable((ModifyTableState *) node);
            break;
 
        case T_AppendState:
            ExecReScanAppend((AppendState *) node);
            break;
 
        case T_MergeAppendState:
            ExecReScanMergeAppend((MergeAppendState *) node);
            break;
 
        case T_RecursiveUnionState:
            ExecReScanRecursiveUnion((RecursiveUnionState *) node);
            break;
 
        case T_BitmapAndState:
            ExecReScanBitmapAnd((BitmapAndState *) node);
            break;
 
        case T_BitmapOrState:
            ExecReScanBitmapOr((BitmapOrState *) node);
            break;
 
        case T_SeqScanState:
            ExecReScanSeqScan((SeqScanState *) node);
            break;
 
        case T_SampleScanState:
            ExecReScanSampleScan((SampleScanState *) node);
            break;
 
        case T_GatherState:
            ExecReScanGather((GatherState *) node);
            break;
 
        case T_GatherMergeState:
            ExecReScanGatherMerge((GatherMergeState *) node);
            break;
 
        case T_IndexScanState:
            ExecReScanIndexScan((IndexScanState *) node);
            break;
 
        case T_IndexOnlyScanState:
            ExecReScanIndexOnlyScan((IndexOnlyScanState *) node);
            break;
 
        case T_BitmapIndexScanState:
            ExecReScanBitmapIndexScan((BitmapIndexScanState *) node);
            break;
 
        case T_BitmapHeapScanState:
            ExecReScanBitmapHeapScan((BitmapHeapScanState *) node);
            break;
 
        case T_TidScanState:
            ExecReScanTidScan((TidScanState *) node);
            break;
 
        case T_TidRangeScanState:
            ExecReScanTidRangeScan((TidRangeScanState *) node);
            break;
 
        case T_SubqueryScanState:
            ExecReScanSubqueryScan((SubqueryScanState *) node);
            break;
 
        case T_FunctionScanState:
            ExecReScanFunctionScan((FunctionScanState *) node);
            break;
 
        case T_TableFuncScanState:
            ExecReScanTableFuncScan((TableFuncScanState *) node);
            break;
 
        case T_ValuesScanState:
            ExecReScanValuesScan((ValuesScanState *) node);
            break;
 
        case T_CteScanState:
            ExecReScanCteScan((CteScanState *) node);
            break;
 
        case T_NamedTuplestoreScanState:
            ExecReScanNamedTuplestoreScan((NamedTuplestoreScanState *) node);
            break;
 
        case T_WorkTableScanState:
            ExecReScanWorkTableScan((WorkTableScanState *) node);
            break;
 
        case T_ForeignScanState:
            ExecReScanForeignScan((ForeignScanState *) node);
            break;
 
        case T_CustomScanState:
            ExecReScanCustomScan((CustomScanState *) node);
            break;
 
        case T_NestLoopState:
            ExecReScanNestLoop((NestLoopState *) node);
            break;
 
        case T_MergeJoinState:
            ExecReScanMergeJoin((MergeJoinState *) node);
            break;
 
        case T_HashJoinState:
            ExecReScanHashJoin((HashJoinState *) node);
            break;
 
        case T_MaterialState:
            ExecReScanMaterial((MaterialState *) node);
            break;
 
        case T_MemoizeState:
            ExecReScanMemoize((MemoizeState *) node);
            break;
 
        case T_SortState:
            ExecReScanSort((SortState *) node);
            break;
 
        case T_IncrementalSortState:
            ExecReScanIncrementalSort((IncrementalSortState *) node);
            break;
 
        case T_GroupState:
            ExecReScanGroup((GroupState *) node);
            break;
 
        case T_AggState:
            ExecReScanAgg((AggState *) node);
            break;
 
        case T_WindowAggState:
            ExecReScanWindowAgg((WindowAggState *) node);
            break;
 
        case T_UniqueState:
            ExecReScanUnique((UniqueState *) node);
            break;
 
        case T_HashState:
            ExecReScanHash((HashState *) node);
            break;
 
        case T_SetOpState:
            ExecReScanSetOp((SetOpState *) node);
            break;
 
        case T_LockRowsState:
            ExecReScanLockRows((LockRowsState *) node);
            break;
 
        case T_LimitState:
            ExecReScanLimit((LimitState *) node);
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
            break;
    }
 
    if (node->chgParam != NULL)
    {
        bms_free(node->chgParam);
        node->chgParam = NULL;
    }
}

References bms_free(), PlanState::chgParam, elog, ERROR, ExecReScanAgg(), ExecReScanAppend(), ExecReScanBitmapAnd(), ExecReScanBitmapHeapScan(), ExecReScanBitmapIndexScan(), ExecReScanBitmapOr(), ExecReScanCteScan(), ExecReScanCustomScan(), ExecReScanForeignScan(), ExecReScanFunctionScan(), ExecReScanGather(), ExecReScanGatherMerge(), ExecReScanGroup(), ExecReScanHash(), ExecReScanHashJoin(), ExecReScanIncrementalSort(), ExecReScanIndexOnlyScan(), ExecReScanIndexScan(), ExecReScanLimit(), ExecReScanLockRows(), ExecReScanMaterial(), ExecReScanMemoize(), ExecReScanMergeAppend(), ExecReScanMergeJoin(), ExecReScanModifyTable(), ExecReScanNamedTuplestoreScan(), ExecReScanNestLoop(), ExecReScanProjectSet(), ExecReScanRecursiveUnion(), ExecReScanResult(), ExecReScanSampleScan(), ExecReScanSeqScan(), ExecReScanSetOp(), ExecReScanSetParamPlan(), ExecReScanSort(), ExecReScanSubqueryScan(), ExecReScanTableFuncScan(), ExecReScanTidRangeScan(), ExecReScanTidScan(), ExecReScanUnique(), ExecReScanValuesScan(), ExecReScanWindowAgg(), ExecReScanWorkTableScan(), PlanState::initPlan, innerPlanState, InstrEndLoop(), PlanState::instrument, lfirst, nodeTag, outerPlanState, SubPlanState::planstate, PlanState::ps_ExprContext, ReScanExprContext(), splan, PlanState::subPlan, and UpdateChangedParamSet().

Referenced by buildSubPlanHash(), ExecAsyncRequest(), ExecIndexOnlyScan(), ExecIndexScan(), ExecNestLoop(), ExecProcNode(), ExecReScanAgg(), ExecReScanAppend(), ExecReScanBitmapAnd(), ExecReScanBitmapHeapScan(), ExecReScanBitmapOr(), ExecReScanForeignScan(), ExecReScanGather(), ExecReScanGatherMerge(), ExecReScanGroup(), ExecReScanHash(), ExecReScanHashJoin(), ExecReScanIncrementalSort(), ExecReScanLimit(), ExecReScanLockRows(), ExecReScanMaterial(), ExecReScanMemoize(), ExecReScanMergeAppend(), ExecReScanMergeJoin(), ExecReScanNestLoop(), ExecReScanProjectSet(), ExecReScanRecursiveUnion(), ExecReScanResult(), ExecReScanSetOp(), ExecReScanSort(), ExecReScanSubqueryScan(), ExecReScanUnique(), ExecReScanWindowAgg(), ExecScanSubPlan(), ExecutorRewind(), MultiExecBitmapIndexScan(), and MultiExecProcNode().

◆ ExecRestrPos()

void ExecRestrPos ( PlanState * node )

Definition at line 376 of file execAmi.c.

{
    switch (nodeTag(node))
    {
        case T_IndexScanState:
            ExecIndexRestrPos((IndexScanState *) node);
            break;
 
        case T_IndexOnlyScanState:
            ExecIndexOnlyRestrPos((IndexOnlyScanState *) node);
            break;
 
        case T_CustomScanState:
            ExecCustomRestrPos((CustomScanState *) node);
            break;
 
        case T_MaterialState:
            ExecMaterialRestrPos((MaterialState *) node);
            break;
 
        case T_SortState:
            ExecSortRestrPos((SortState *) node);
            break;
 
        case T_ResultState:
            ExecResultRestrPos((ResultState *) node);
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
            break;
    }
}

References elog, ERROR, ExecCustomRestrPos(), ExecIndexOnlyRestrPos(), ExecIndexRestrPos(), ExecMaterialRestrPos(), ExecResultRestrPos(), ExecSortRestrPos(), and nodeTag.

Referenced by ExecMergeJoin(), and ExecResultRestrPos().

◆ ExecScan()

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

Definition at line 47 of file execScan.c.

{
    EPQState   *epqstate;
    ExprState  *qual;
    ProjectionInfo *projInfo;
 
    epqstate = node->ps.state->es_epq_active;
    qual = node->ps.qual;
    projInfo = node->ps.ps_ProjInfo;
 
    return ExecScanExtended(node,
                            accessMtd,
                            recheckMtd,
                            epqstate,
                            qual,
                            projInfo);
}

References EState::es_epq_active, ExecScanExtended(), ScanState::ps, PlanState::ps_ProjInfo, PlanState::qual, and PlanState::state.

Referenced by ExecBitmapHeapScan(), ExecCteScan(), ExecForeignScan(), ExecFunctionScan(), ExecIndexOnlyScan(), ExecIndexScan(), ExecNamedTuplestoreScan(), ExecSampleScan(), ExecSeqScanEPQ(), ExecSubqueryScan(), ExecTableFuncScan(), ExecTidRangeScan(), ExecTidScan(), ExecValuesScan(), and ExecWorkTableScan().

◆ ExecScanReScan()

void ExecScanReScan ( ScanState * node )

Definition at line 108 of file execScan.c.

{
    EState     *estate = node->ps.state;
 
    /*
     * We must clear the scan tuple so that observers (e.g., execCurrent.c)
     * can tell that this plan node is not positioned on a tuple.
     */
    ExecClearTuple(node->ss_ScanTupleSlot);
 
    /*
     * Rescan EvalPlanQual tuple(s) if we're inside an EvalPlanQual recheck.
     * But don't lose the "blocked" status of blocked target relations.
     */
    if (estate->es_epq_active != NULL)
    {
        EPQState   *epqstate = estate->es_epq_active;
        Index       scanrelid = ((Scan *) node->ps.plan)->scanrelid;
 
        if (scanrelid > 0)
            epqstate->relsubs_done[scanrelid - 1] =
                epqstate->relsubs_blocked[scanrelid - 1];
        else
        {
            Bitmapset  *relids;
            int         rtindex = -1;
 
            /*
             * If an FDW or custom scan provider has replaced the join with a
             * scan, there are multiple RTIs; reset the epqScanDone flag for
             * all of them.
             */
            if (IsA(node->ps.plan, ForeignScan))
                relids = ((ForeignScan *) node->ps.plan)->fs_base_relids;
            else if (IsA(node->ps.plan, CustomScan))
                relids = ((CustomScan *) node->ps.plan)->custom_relids;
            else
                elog(ERROR, "unexpected scan node: %d",
                     (int) nodeTag(node->ps.plan));
 
            while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
            {
                Assert(rtindex > 0);
                epqstate->relsubs_done[rtindex - 1] =
                    epqstate->relsubs_blocked[rtindex - 1];
            }
        }
    }
}

References Assert(), bms_next_member(), elog, ERROR, EState::es_epq_active, ExecClearTuple(), IsA, nodeTag, PlanState::plan, ScanState::ps, EPQState::relsubs_blocked, EPQState::relsubs_done, ScanState::ss_ScanTupleSlot, and PlanState::state.

Referenced by ExecReScanBitmapHeapScan(), ExecReScanCteScan(), ExecReScanForeignScan(), ExecReScanFunctionScan(), ExecReScanIndexOnlyScan(), ExecReScanIndexScan(), ExecReScanNamedTuplestoreScan(), ExecReScanSampleScan(), ExecReScanSeqScan(), ExecReScanSubqueryScan(), ExecReScanTableFuncScan(), ExecReScanTidRangeScan(), ExecReScanTidScan(), ExecReScanValuesScan(), and ExecReScanWorkTableScan().

◆ ExecSetExecProcNode()

void ExecSetExecProcNode	(	PlanState *	node,
		ExecProcNodeMtd	function
	)

Definition at line 430 of file execProcnode.c.

{
    /*
     * Add a wrapper around the ExecProcNode callback that checks stack depth
     * during the first execution and maybe adds an instrumentation wrapper.
     * When the callback is changed after execution has already begun that
     * means we'll superfluously execute ExecProcNodeFirst, but that seems ok.
     */
    node->ExecProcNodeReal = function;
    node->ExecProcNode = ExecProcNodeFirst;
}

References PlanState::ExecProcNode, ExecProcNodeFirst(), PlanState::ExecProcNodeReal, and function.

Referenced by ExecHashJoinInitializeDSM(), ExecHashJoinInitializeWorker(), and ExecInitNode().

◆ ExecSetTupleBound()

void ExecSetTupleBound	(	int64	tuples_needed,
		PlanState *	child_node
	)

Definition at line 848 of file execProcnode.c.

{
    /*
     * Since this function recurses, in principle we should check stack depth
     * here.  In practice, it's probably pointless since the earlier node
     * initialization tree traversal would surely have consumed more stack.
     */
 
    if (IsA(child_node, SortState))
    {
        /*
         * If it is a Sort node, notify it that it can use bounded sort.
         *
         * Note: it is the responsibility of nodeSort.c to react properly to
         * changes of these parameters.  If we ever redesign this, it'd be a
         * good idea to integrate this signaling with the parameter-change
         * mechanism.
         */
        SortState  *sortState = (SortState *) child_node;
 
        if (tuples_needed < 0)
        {
            /* make sure flag gets reset if needed upon rescan */
            sortState->bounded = false;
        }
        else
        {
            sortState->bounded = true;
            sortState->bound = tuples_needed;
        }
    }
    else if (IsA(child_node, IncrementalSortState))
    {
        /*
         * If it is an IncrementalSort node, notify it that it can use bounded
         * sort.
         *
         * Note: it is the responsibility of nodeIncrementalSort.c to react
         * properly to changes of these parameters.  If we ever redesign this,
         * it'd be a good idea to integrate this signaling with the
         * parameter-change mechanism.
         */
        IncrementalSortState *sortState = (IncrementalSortState *) child_node;
 
        if (tuples_needed < 0)
        {
            /* make sure flag gets reset if needed upon rescan */
            sortState->bounded = false;
        }
        else
        {
            sortState->bounded = true;
            sortState->bound = tuples_needed;
        }
    }
    else if (IsA(child_node, AppendState))
    {
        /*
         * If it is an Append, we can apply the bound to any nodes that are
         * children of the Append, since the Append surely need read no more
         * than that many tuples from any one input.
         */
        AppendState *aState = (AppendState *) child_node;
        int         i;
 
        for (i = 0; i < aState->as_nplans; i++)
            ExecSetTupleBound(tuples_needed, aState->appendplans[i]);
    }
    else if (IsA(child_node, MergeAppendState))
    {
        /*
         * If it is a MergeAppend, we can apply the bound to any nodes that
         * are children of the MergeAppend, since the MergeAppend surely need
         * read no more than that many tuples from any one input.
         */
        MergeAppendState *maState = (MergeAppendState *) child_node;
        int         i;
 
        for (i = 0; i < maState->ms_nplans; i++)
            ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
    }
    else if (IsA(child_node, ResultState))
    {
        /*
         * Similarly, for a projecting Result, we can apply the bound to its
         * child node.
         *
         * If Result supported qual checking, we'd have to punt on seeing a
         * qual.  Note that having a resconstantqual is not a showstopper: if
         * that condition succeeds it affects nothing, while if it fails, no
         * rows will be demanded from the Result child anyway.
         */
        if (outerPlanState(child_node))
            ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
    }
    else if (IsA(child_node, SubqueryScanState))
    {
        /*
         * We can also descend through SubqueryScan, but only if it has no
         * qual (otherwise it might discard rows).
         */
        SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
 
        if (subqueryState->ss.ps.qual == NULL)
            ExecSetTupleBound(tuples_needed, subqueryState->subplan);
    }
    else if (IsA(child_node, GatherState))
    {
        /*
         * A Gather node can propagate the bound to its workers.  As with
         * MergeAppend, no one worker could possibly need to return more
         * tuples than the Gather itself needs to.
         *
         * Note: As with Sort, the Gather node is responsible for reacting
         * properly to changes to this parameter.
         */
        GatherState *gstate = (GatherState *) child_node;
 
        gstate->tuples_needed = tuples_needed;
 
        /* Also pass down the bound to our own copy of the child plan */
        ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
    }
    else if (IsA(child_node, GatherMergeState))
    {
        /* Same comments as for Gather */
        GatherMergeState *gstate = (GatherMergeState *) child_node;
 
        gstate->tuples_needed = tuples_needed;
 
        ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
    }
 
    /*
     * In principle we could descend through any plan node type that is
     * certain not to discard or combine input rows; but on seeing a node that
     * can do that, we can't propagate the bound any further.  For the moment
     * it's unclear that any other cases are worth checking here.
     */
}

References AppendState::appendplans, AppendState::as_nplans, SortState::bound, IncrementalSortState::bound, SortState::bounded, IncrementalSortState::bounded, ExecSetTupleBound(), i, IsA, MergeAppendState::mergeplans, MergeAppendState::ms_nplans, outerPlanState, ScanState::ps, PlanState::qual, SubqueryScanState::ss, SubqueryScanState::subplan, GatherState::tuples_needed, and GatherMergeState::tuples_needed.

Referenced by ExecSetTupleBound(), ParallelQueryMain(), and recompute_limits().

◆ ExecShouldLockRelations()

static bool ExecShouldLockRelations ( EState * estate )

inlinestatic

Definition at line 281 of file executor.h.

{
    return estate->es_cachedplan == NULL ? false :
        CachedPlanRequiresLocking(estate->es_cachedplan);
}

References CachedPlanRequiresLocking(), EState::es_cachedplan, and false.

Referenced by ExecDoInitialPruning().

◆ ExecShutdownNode()

void ExecShutdownNode ( PlanState * node )

Definition at line 772 of file execProcnode.c.

{
    (void) ExecShutdownNode_walker(node, NULL);
}

References ExecShutdownNode_walker().

Referenced by ExecutePlan().

◆ ExecSimpleRelationDelete()

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

Definition at line 696 of file execReplication.c.

{
    bool        skip_tuple = false;
    Relation    rel = resultRelInfo->ri_RelationDesc;
    ItemPointer tid = &searchslot->tts_tid;
 
    CheckCmdReplicaIdentity(rel, CMD_DELETE);
 
    /* BEFORE ROW DELETE Triggers */
    if (resultRelInfo->ri_TrigDesc &&
        resultRelInfo->ri_TrigDesc->trig_delete_before_row)
    {
        skip_tuple = !ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
                                           tid, NULL, NULL, NULL, NULL);
    }
 
    if (!skip_tuple)
    {
        /* OK, delete the tuple */
        simple_table_tuple_delete(rel, tid, estate->es_snapshot);
 
        /* AFTER ROW DELETE Triggers */
        ExecARDeleteTriggers(estate, resultRelInfo,
                             tid, NULL, NULL, false);
    }
}

References CheckCmdReplicaIdentity(), CMD_DELETE, EState::es_snapshot, ExecARDeleteTriggers(), ExecBRDeleteTriggers(), ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, simple_table_tuple_delete(), TriggerDesc::trig_delete_before_row, and TupleTableSlot::tts_tid.

Referenced by apply_handle_delete_internal(), and apply_handle_tuple_routing().

◆ ExecSimpleRelationInsert()

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

Definition at line 524 of file execReplication.c.

{
    bool        skip_tuple = false;
    Relation    rel = resultRelInfo->ri_RelationDesc;
 
    /* For now we support only tables. */
    Assert(rel->rd_rel->relkind == RELKIND_RELATION);
 
    CheckCmdReplicaIdentity(rel, CMD_INSERT);
 
    /* BEFORE ROW INSERT Triggers */
    if (resultRelInfo->ri_TrigDesc &&
        resultRelInfo->ri_TrigDesc->trig_insert_before_row)
    {
        if (!ExecBRInsertTriggers(estate, resultRelInfo, slot))
            skip_tuple = true;  /* "do nothing" */
    }
 
    if (!skip_tuple)
    {
        List       *recheckIndexes = NIL;
        List       *conflictindexes;
        bool        conflict = false;
 
        /* Compute stored generated columns */
        if (rel->rd_att->constr &&
            rel->rd_att->constr->has_generated_stored)
            ExecComputeStoredGenerated(resultRelInfo, estate, slot,
                                       CMD_INSERT);
 
        /* Check the constraints of the tuple */
        if (rel->rd_att->constr)
            ExecConstraints(resultRelInfo, slot, estate);
        if (rel->rd_rel->relispartition)
            ExecPartitionCheck(resultRelInfo, slot, estate, true);
 
        /* OK, store the tuple and create index entries for it */
        simple_table_tuple_insert(resultRelInfo->ri_RelationDesc, slot);
 
        conflictindexes = resultRelInfo->ri_onConflictArbiterIndexes;
 
        if (resultRelInfo->ri_NumIndices > 0)
            recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
                                                   slot, estate, false,
                                                   conflictindexes ? true : false,
                                                   &conflict,
                                                   conflictindexes, false);
 
        /*
         * Checks the conflict indexes to fetch the conflicting local tuple
         * and reports the conflict. We perform this check here, instead of
         * performing an additional index scan before the actual insertion and
         * reporting the conflict if any conflicting tuples are found. This is
         * to avoid the overhead of executing the extra scan for each INSERT
         * operation, even when no conflict arises, which could introduce
         * significant overhead to replication, particularly in cases where
         * conflicts are rare.
         *
         * XXX OTOH, this could lead to clean-up effort for dead tuples added
         * in heap and index in case of conflicts. But as conflicts shouldn't
         * be a frequent thing so we preferred to save the performance
         * overhead of extra scan before each insertion.
         */
        if (conflict)
            CheckAndReportConflict(resultRelInfo, estate, CT_INSERT_EXISTS,
                                   recheckIndexes, NULL, slot);
 
        /* AFTER ROW INSERT Triggers */
        ExecARInsertTriggers(estate, resultRelInfo, slot,
                             recheckIndexes, NULL);
 
        /*
         * XXX we should in theory pass a TransitionCaptureState object to the
         * above to capture transition tuples, but after statement triggers
         * don't actually get fired by replication yet anyway
         */
 
        list_free(recheckIndexes);
    }
}

References Assert(), CheckAndReportConflict(), CheckCmdReplicaIdentity(), CMD_INSERT, TupleDescData::constr, CT_INSERT_EXISTS, ExecARInsertTriggers(), ExecBRInsertTriggers(), ExecComputeStoredGenerated(), ExecConstraints(), ExecInsertIndexTuples(), ExecPartitionCheck(), TupleConstr::has_generated_stored, list_free(), NIL, RelationData::rd_att, RelationData::rd_rel, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_onConflictArbiterIndexes, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, simple_table_tuple_insert(), and TriggerDesc::trig_insert_before_row.

Referenced by apply_handle_insert_internal().

◆ ExecSimpleRelationUpdate()

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

Definition at line 613 of file execReplication.c.

{
    bool        skip_tuple = false;
    Relation    rel = resultRelInfo->ri_RelationDesc;
    ItemPointer tid = &(searchslot->tts_tid);
 
    /*
     * We support only non-system tables, with
     * check_publication_add_relation() accountable.
     */
    Assert(rel->rd_rel->relkind == RELKIND_RELATION);
    Assert(!IsCatalogRelation(rel));
 
    CheckCmdReplicaIdentity(rel, CMD_UPDATE);
 
    /* BEFORE ROW UPDATE Triggers */
    if (resultRelInfo->ri_TrigDesc &&
        resultRelInfo->ri_TrigDesc->trig_update_before_row)
    {
        if (!ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
                                  tid, NULL, slot, NULL, NULL))
            skip_tuple = true;  /* "do nothing" */
    }
 
    if (!skip_tuple)
    {
        List       *recheckIndexes = NIL;
        TU_UpdateIndexes update_indexes;
        List       *conflictindexes;
        bool        conflict = false;
 
        /* Compute stored generated columns */
        if (rel->rd_att->constr &&
            rel->rd_att->constr->has_generated_stored)
            ExecComputeStoredGenerated(resultRelInfo, estate, slot,
                                       CMD_UPDATE);
 
        /* Check the constraints of the tuple */
        if (rel->rd_att->constr)
            ExecConstraints(resultRelInfo, slot, estate);
        if (rel->rd_rel->relispartition)
            ExecPartitionCheck(resultRelInfo, slot, estate, true);
 
        simple_table_tuple_update(rel, tid, slot, estate->es_snapshot,
                                  &update_indexes);
 
        conflictindexes = resultRelInfo->ri_onConflictArbiterIndexes;
 
        if (resultRelInfo->ri_NumIndices > 0 && (update_indexes != TU_None))
            recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
                                                   slot, estate, true,
                                                   conflictindexes ? true : false,
                                                   &conflict, conflictindexes,
                                                   (update_indexes == TU_Summarizing));
 
        /*
         * Refer to the comments above the call to CheckAndReportConflict() in
         * ExecSimpleRelationInsert to understand why this check is done at
         * this point.
         */
        if (conflict)
            CheckAndReportConflict(resultRelInfo, estate, CT_UPDATE_EXISTS,
                                   recheckIndexes, searchslot, slot);
 
        /* AFTER ROW UPDATE Triggers */
        ExecARUpdateTriggers(estate, resultRelInfo,
                             NULL, NULL,
                             tid, NULL, slot,
                             recheckIndexes, NULL, false);
 
        list_free(recheckIndexes);
    }
}

References Assert(), CheckAndReportConflict(), CheckCmdReplicaIdentity(), CMD_UPDATE, TupleDescData::constr, CT_UPDATE_EXISTS, EState::es_snapshot, ExecARUpdateTriggers(), ExecBRUpdateTriggers(), ExecComputeStoredGenerated(), ExecConstraints(), ExecInsertIndexTuples(), ExecPartitionCheck(), TupleConstr::has_generated_stored, IsCatalogRelation(), list_free(), NIL, RelationData::rd_att, RelationData::rd_rel, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_onConflictArbiterIndexes, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, simple_table_tuple_update(), TriggerDesc::trig_update_before_row, TupleTableSlot::tts_tid, TU_None, and TU_Summarizing.

Referenced by apply_handle_tuple_routing(), and apply_handle_update_internal().

◆ ExecSupportsBackwardScan()

bool ExecSupportsBackwardScan ( Plan * node )

Definition at line 511 of file execAmi.c.

{
    if (node == NULL)
        return false;
 
    /*
     * Parallel-aware nodes return a subset of the tuples in each worker, and
     * in general we can't expect to have enough bookkeeping state to know
     * which ones we returned in this worker as opposed to some other worker.
     */
    if (node->parallel_aware)
        return false;
 
    switch (nodeTag(node))
    {
        case T_Result:
            if (outerPlan(node) != NULL)
                return ExecSupportsBackwardScan(outerPlan(node));
            else
                return false;
 
        case T_Append:
            {
                ListCell   *l;
 
                /* With async, tuples may be interleaved, so can't back up. */
                if (((Append *) node)->nasyncplans > 0)
                    return false;
 
                foreach(l, ((Append *) node)->appendplans)
                {
                    if (!ExecSupportsBackwardScan((Plan *) lfirst(l)))
                        return false;
                }
                /* need not check tlist because Append doesn't evaluate it */
                return true;
            }
 
        case T_SampleScan:
            /* Simplify life for tablesample methods by disallowing this */
            return false;
 
        case T_Gather:
            return false;
 
        case T_IndexScan:
            return IndexSupportsBackwardScan(((IndexScan *) node)->indexid);
 
        case T_IndexOnlyScan:
            return IndexSupportsBackwardScan(((IndexOnlyScan *) node)->indexid);
 
        case T_SubqueryScan:
            return ExecSupportsBackwardScan(((SubqueryScan *) node)->subplan);
 
        case T_CustomScan:
            if (((CustomScan *) node)->flags & CUSTOMPATH_SUPPORT_BACKWARD_SCAN)
                return true;
            return false;
 
        case T_SeqScan:
        case T_TidScan:
        case T_TidRangeScan:
        case T_FunctionScan:
        case T_ValuesScan:
        case T_CteScan:
        case T_Material:
        case T_Sort:
            /* these don't evaluate tlist */
            return true;
 
        case T_IncrementalSort:
 
            /*
             * Unlike full sort, incremental sort keeps only a single group of
             * tuples in memory, so it can't scan backwards.
             */
            return false;
 
        case T_LockRows:
        case T_Limit:
            return ExecSupportsBackwardScan(outerPlan(node));
 
        default:
            return false;
    }
}

References CUSTOMPATH_SUPPORT_BACKWARD_SCAN, ExecSupportsBackwardScan(), IndexSupportsBackwardScan(), lfirst, nodeTag, outerPlan, and Plan::parallel_aware.

Referenced by ExecSupportsBackwardScan(), PerformCursorOpen(), SPI_cursor_open_internal(), and standard_planner().

◆ ExecSupportsMarkRestore()

bool ExecSupportsMarkRestore ( struct Path * pathnode )

Definition at line 418 of file execAmi.c.

{
    /*
     * For consistency with the routines above, we do not examine the nodeTag
     * but rather the pathtype, which is the Plan node type the Path would
     * produce.
     */
    switch (pathnode->pathtype)
    {
        case T_IndexScan:
        case T_IndexOnlyScan:
 
            /*
             * Not all index types support mark/restore.
             */
            return castNode(IndexPath, pathnode)->indexinfo->amcanmarkpos;
 
        case T_Material:
        case T_Sort:
            return true;
 
        case T_CustomScan:
            if (castNode(CustomPath, pathnode)->flags & CUSTOMPATH_SUPPORT_MARK_RESTORE)
                return true;
            return false;
 
        case T_Result:
 
            /*
             * Result supports mark/restore iff it has a child plan that does.
             *
             * We have to be careful here because there is more than one Path
             * type that can produce a Result plan node.
             */
            if (IsA(pathnode, ProjectionPath))
                return ExecSupportsMarkRestore(((ProjectionPath *) pathnode)->subpath);
            else if (IsA(pathnode, MinMaxAggPath))
                return false;   /* childless Result */
            else if (IsA(pathnode, GroupResultPath))
                return false;   /* childless Result */
            else
            {
                /* Simple RTE_RESULT base relation */
                Assert(IsA(pathnode, Path));
                return false;   /* childless Result */
            }
 
        case T_Append:
            {
                AppendPath *appendPath = castNode(AppendPath, pathnode);
 
                /*
                 * If there's exactly one child, then there will be no Append
                 * in the final plan, so we can handle mark/restore if the
                 * child plan node can.
                 */
                if (list_length(appendPath->subpaths) == 1)
                    return ExecSupportsMarkRestore((Path *) linitial(appendPath->subpaths));
                /* Otherwise, Append can't handle it */
                return false;
            }
 
        case T_MergeAppend:
            {
                MergeAppendPath *mapath = castNode(MergeAppendPath, pathnode);
 
                /*
                 * Like the Append case above, single-subpath MergeAppends
                 * won't be in the final plan, so just return the child's
                 * mark/restore ability.
                 */
                if (list_length(mapath->subpaths) == 1)
                    return ExecSupportsMarkRestore((Path *) linitial(mapath->subpaths));
                /* Otherwise, MergeAppend can't handle it */
                return false;
            }
 
        default:
            break;
    }
 
    return false;
}

References Assert(), castNode, CUSTOMPATH_SUPPORT_MARK_RESTORE, ExecSupportsMarkRestore(), IsA, linitial, list_length(), Path::pathtype, subpath(), AppendPath::subpaths, and MergeAppendPath::subpaths.

Referenced by ExecSupportsMarkRestore(), and final_cost_mergejoin().

◆ ExecTargetListLength()

int ExecTargetListLength ( List * targetlist )

Definition at line 1177 of file execUtils.c.

{
    /* This used to be more complex, but fjoins are dead */
    return list_length(targetlist);
}

References list_length().

Referenced by ExecTypeFromTLInternal().

◆ execTuplesHashPrepare()

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

Definition at line 97 of file execGrouping.c.

{
    int         i;
 
    *eqFuncOids = (Oid *) palloc(numCols * sizeof(Oid));
    *hashFunctions = (FmgrInfo *) palloc(numCols * sizeof(FmgrInfo));
 
    for (i = 0; i < numCols; i++)
    {
        Oid         eq_opr = eqOperators[i];
        Oid         eq_function;
        Oid         left_hash_function;
        Oid         right_hash_function;
 
        eq_function = get_opcode(eq_opr);
        if (!get_op_hash_functions(eq_opr,
                                   &left_hash_function, &right_hash_function))
            elog(ERROR, "could not find hash function for hash operator %u",
                 eq_opr);
        /* We're not supporting cross-type cases here */
        Assert(left_hash_function == right_hash_function);
        (*eqFuncOids)[i] = eq_function;
        fmgr_info(right_hash_function, &(*hashFunctions)[i]);
    }
}

References Assert(), elog, ERROR, fmgr_info(), get_op_hash_functions(), get_opcode(), i, and palloc().

Referenced by ExecInitRecursiveUnion(), ExecInitSetOp(), and find_hash_columns().

◆ execTuplesMatchPrepare()

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

Definition at line 58 of file execGrouping.c.

{
    Oid        *eqFunctions;
    int         i;
    ExprState  *expr;
 
    if (numCols == 0)
        return NULL;
 
    eqFunctions = (Oid *) palloc(numCols * sizeof(Oid));
 
    /* lookup equality functions */
    for (i = 0; i < numCols; i++)
        eqFunctions[i] = get_opcode(eqOperators[i]);
 
    /* build actual expression */
    expr = ExecBuildGroupingEqual(desc, desc, NULL, NULL,
                                  numCols, keyColIdx, eqFunctions, collations,
                                  parent);
 
    return expr;
}

References ExecBuildGroupingEqual(), get_opcode(), i, and palloc().

Referenced by build_pertrans_for_aggref(), ExecInitAgg(), ExecInitGroup(), ExecInitLimit(), ExecInitUnique(), ExecInitWindowAgg(), and hypothetical_dense_rank_final().

◆ ExecTypeFromExprList()

TupleDesc ExecTypeFromExprList ( List * exprList )

Definition at line 2184 of file execTuples.c.

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

References CreateTemplateTupleDesc(), exprCollation(), exprType(), exprTypmod(), lfirst, list_length(), TupleDescInitEntry(), and TupleDescInitEntryCollation().

Referenced by ExecInitExprRec(), ExecInitMemoize(), and ExecInitValuesScan().

◆ ExecTypeFromTL()

TupleDesc ExecTypeFromTL ( List * targetList )

Definition at line 2125 of file execTuples.c.

{
    return ExecTypeFromTLInternal(targetList, false);
}

References ExecTypeFromTLInternal().

Referenced by build_pertrans_for_aggref(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitIndexOnlyScan(), ExecInitResultTypeTL(), ExecInitSubPlan(), find_hash_columns(), and ordered_set_startup().

◆ ExecTypeSetColNames()

void ExecTypeSetColNames	(	TupleDesc	typeInfo,
		List *	namesList
	)

Definition at line 2217 of file execTuples.c.

{
    int         colno = 0;
    ListCell   *lc;
 
    /* It's only OK to change col names in a not-yet-blessed RECORD type */
    Assert(typeInfo->tdtypeid == RECORDOID);
    Assert(typeInfo->tdtypmod < 0);
 
    foreach(lc, namesList)
    {
        char       *cname = strVal(lfirst(lc));
        Form_pg_attribute attr;
 
        /* Guard against too-long names list (probably can't happen) */
        if (colno >= typeInfo->natts)
            break;
        attr = TupleDescAttr(typeInfo, colno);
        colno++;
 
        /*
         * Do nothing for empty aliases or dropped columns (these cases
         * probably can't arise in RECORD types, either)
         */
        if (cname[0] == '\0' || attr->attisdropped)
            continue;
 
        /* OK, assign the column name */
        namestrcpy(&(attr->attname), cname);
    }
}

References Assert(), lfirst, namestrcpy(), TupleDescData::natts, strVal, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and TupleDescAttr().

Referenced by ExecEvalWholeRowVar(), and ExecInitExprRec().

◆ ExecUpdateLockMode()

LockTupleMode ExecUpdateLockMode	(	EState *	estate,
		ResultRelInfo *	relinfo
	)

Definition at line 2491 of file execMain.c.

{
    Bitmapset  *keyCols;
    Bitmapset  *updatedCols;
 
    /*
     * Compute lock mode to use.  If columns that are part of the key have not
     * been modified, then we can use a weaker lock, allowing for better
     * concurrency.
     */
    updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
    keyCols = RelationGetIndexAttrBitmap(relinfo->ri_RelationDesc,
                                         INDEX_ATTR_BITMAP_KEY);
 
    if (bms_overlap(keyCols, updatedCols))
        return LockTupleExclusive;
 
    return LockTupleNoKeyExclusive;
}

References bms_overlap(), ExecGetAllUpdatedCols(), INDEX_ATTR_BITMAP_KEY, LockTupleExclusive, LockTupleNoKeyExclusive, RelationGetIndexAttrBitmap(), and ResultRelInfo::ri_RelationDesc.

Referenced by ExecBRUpdateTriggers(), ExecMergeMatched(), and ExecOnConflictUpdate().

◆ executor_errposition()

int executor_errposition	(	EState *	estate,
		int	location
	)

Definition at line 938 of file execUtils.c.

{
    int         pos;
 
    /* No-op if location was not provided */
    if (location < 0)
        return 0;
    /* Can't do anything if source text is not available */
    if (estate == NULL || estate->es_sourceText == NULL)
        return 0;
    /* Convert offset to character number */
    pos = pg_mbstrlen_with_len(estate->es_sourceText, location) + 1;
    /* And pass it to the ereport mechanism */
    return errposition(pos);
}

References errposition(), EState::es_sourceText, and pg_mbstrlen_with_len().

Referenced by ExecInitFunc(), ExecInitSubscriptingRef(), and init_sexpr().

◆ ExecutorEnd()

void ExecutorEnd ( QueryDesc * queryDesc )

Definition at line 535 of file execMain.c.

{
    if (ExecutorEnd_hook)
        (*ExecutorEnd_hook) (queryDesc);
    else
        standard_ExecutorEnd(queryDesc);
}

References ExecutorEnd_hook, and standard_ExecutorEnd().

Referenced by _SPI_pquery(), EndCopyTo(), ExecCreateTableAs(), execute_sql_string(), ExecutorStartCachedPlan(), ExplainOnePlan(), ParallelQueryMain(), PersistHoldablePortal(), PortalCleanup(), postquel_end(), ProcessQuery(), and refresh_matview_datafill().

◆ ExecutorFinish()

void ExecutorFinish ( QueryDesc * queryDesc )

Definition at line 472 of file execMain.c.

{
    if (ExecutorFinish_hook)
        (*ExecutorFinish_hook) (queryDesc);
    else
        standard_ExecutorFinish(queryDesc);
}

References ExecutorFinish_hook, and standard_ExecutorFinish().

Referenced by _SPI_pquery(), EndCopyTo(), ExecCreateTableAs(), execute_sql_string(), ExplainOnePlan(), ParallelQueryMain(), PersistHoldablePortal(), PortalCleanup(), postquel_end(), ProcessQuery(), and refresh_matview_datafill().

◆ ExecutorRewind()

void ExecutorRewind ( QueryDesc * queryDesc )

Definition at line 612 of file execMain.c.

{
    EState     *estate;
    MemoryContext oldcontext;
 
    /* sanity checks */
    Assert(queryDesc != NULL);
 
    estate = queryDesc->estate;
 
    Assert(estate != NULL);
 
    /* It's probably not sensible to rescan updating queries */
    Assert(queryDesc->operation == CMD_SELECT);
 
    /*
     * Switch into per-query memory context
     */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    /*
     * rescan plan
     */
    ExecReScan(queryDesc->planstate);
 
    MemoryContextSwitchTo(oldcontext);
}

References Assert(), CMD_SELECT, EState::es_query_cxt, QueryDesc::estate, ExecReScan(), MemoryContextSwitchTo(), QueryDesc::operation, and QueryDesc::planstate.

Referenced by DoPortalRewind(), and PersistHoldablePortal().

◆ ExecutorRun()

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

Definition at line 362 of file execMain.c.

{
    if (ExecutorRun_hook)
        (*ExecutorRun_hook) (queryDesc, direction, count);
    else
        standard_ExecutorRun(queryDesc, direction, count);
}

References ExecutorRun_hook, and standard_ExecutorRun().

Referenced by _SPI_pquery(), DoCopyTo(), ExecCreateTableAs(), execute_sql_string(), ExplainOnePlan(), ParallelQueryMain(), PersistHoldablePortal(), PortalRunSelect(), postquel_getnext(), ProcessQuery(), and refresh_matview_datafill().

◆ ExecutorStart()

bool ExecutorStart	(	QueryDesc *	queryDesc,
		int	eflags
	)

Definition at line 125 of file execMain.c.

{
    bool        plan_valid;
 
    /*
     * In some cases (e.g. an EXECUTE statement or an execute message with the
     * extended query protocol) the query_id won't be reported, so do it now.
     *
     * Note that it's harmless to report the query_id multiple times, as the
     * call will be ignored if the top level query_id has already been
     * reported.
     */
    pgstat_report_query_id(queryDesc->plannedstmt->queryId, false);
 
    if (ExecutorStart_hook)
        plan_valid = (*ExecutorStart_hook) (queryDesc, eflags);
    else
        plan_valid = standard_ExecutorStart(queryDesc, eflags);
 
    return plan_valid;
}

References ExecutorStart_hook, pgstat_report_query_id(), QueryDesc::plannedstmt, PlannedStmt::queryId, and standard_ExecutorStart().

Referenced by _SPI_pquery(), BeginCopyTo(), ExecCreateTableAs(), execute_sql_string(), ExecutorStartCachedPlan(), ExplainOnePlan(), ParallelQueryMain(), PortalStart(), postquel_start(), ProcessQuery(), and refresh_matview_datafill().

◆ ExecutorStartCachedPlan()

void ExecutorStartCachedPlan	(	QueryDesc *	queryDesc,
		int	eflags,
		CachedPlanSource *	plansource,
		int	query_index
	)

Definition at line 292 of file execMain.c.

{
    if (unlikely(queryDesc->cplan == NULL))
        elog(ERROR, "ExecutorStartCachedPlan(): missing CachedPlan");
    if (unlikely(plansource == NULL))
        elog(ERROR, "ExecutorStartCachedPlan(): missing CachedPlanSource");
 
    /*
     * Loop and retry with an updated plan until no further invalidation
     * occurs.
     */
    while (1)
    {
        if (!ExecutorStart(queryDesc, eflags))
        {
            /*
             * Clean up the current execution state before creating the new
             * plan to retry ExecutorStart().  Mark execution as aborted to
             * ensure that AFTER trigger state is properly reset.
             */
            queryDesc->estate->es_aborted = true;
            ExecutorEnd(queryDesc);
 
            /* Retry ExecutorStart() with an updated plan tree. */
            queryDesc->plannedstmt = UpdateCachedPlan(plansource, query_index,
                                                      queryDesc->queryEnv);
        }
        else
 
            /*
             * Exit the loop if the plan is initialized successfully and no
             * sinval messages were received that invalidated the CachedPlan.
             */
            break;
    }
}

References QueryDesc::cplan, elog, ERROR, EState::es_aborted, QueryDesc::estate, ExecutorEnd(), ExecutorStart(), QueryDesc::plannedstmt, QueryDesc::queryEnv, unlikely, and UpdateCachedPlan().

Referenced by _SPI_pquery(), ExplainOnePlan(), PortalStart(), and ProcessQuery().

◆ ExecWithCheckOptions()

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

Definition at line 2189 of file execMain.c.

{
    Relation    rel = resultRelInfo->ri_RelationDesc;
    TupleDesc   tupdesc = RelationGetDescr(rel);
    ExprContext *econtext;
    ListCell   *l1,
               *l2;
 
    /*
     * We will use the EState's per-tuple context for evaluating constraint
     * 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;
 
    /* Check each of the constraints */
    forboth(l1, resultRelInfo->ri_WithCheckOptions,
            l2, resultRelInfo->ri_WithCheckOptionExprs)
    {
        WithCheckOption *wco = (WithCheckOption *) lfirst(l1);
        ExprState  *wcoExpr = (ExprState *) lfirst(l2);
 
        /*
         * Skip any WCOs which are not the kind we are looking for at this
         * time.
         */
        if (wco->kind != kind)
            continue;
 
        /*
         * WITH CHECK OPTION checks are intended to ensure that the new tuple
         * is visible (in the case of a view) or that it passes the
         * 'with-check' policy (in the case of row security). If the qual
         * evaluates to NULL or FALSE, then the new tuple won't be included in
         * the view or doesn't pass the 'with-check' policy for the table.
         */
        if (!ExecQual(wcoExpr, econtext))
        {
            char       *val_desc;
            Bitmapset  *modifiedCols;
 
            switch (wco->kind)
            {
                    /*
                     * For WITH CHECK OPTIONs coming from views, we might be
                     * able to provide the details on the row, depending on
                     * the permissions on the relation (that is, if the user
                     * could view it directly anyway).  For RLS violations, we
                     * don't include the data since we don't know if the user
                     * should be able to view the tuple as that depends on the
                     * USING policy.
                     */
                case WCO_VIEW_CHECK:
                    /* See the comment in ExecConstraints(). */
                    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_WITH_CHECK_OPTION_VIOLATION),
                             errmsg("new row violates check option for view \"%s\"",
                                    wco->relname),
                             val_desc ? errdetail("Failing row contains %s.",
                                                  val_desc) : 0));
                    break;
                case WCO_RLS_INSERT_CHECK:
                case WCO_RLS_UPDATE_CHECK:
                    if (wco->polname != NULL)
                        ereport(ERROR,
                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                                 errmsg("new row violates row-level security policy \"%s\" for table \"%s\"",
                                        wco->polname, wco->relname)));
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                                 errmsg("new row violates row-level security policy for table \"%s\"",
                                        wco->relname)));
                    break;
                case WCO_RLS_MERGE_UPDATE_CHECK:
                case WCO_RLS_MERGE_DELETE_CHECK:
                    if (wco->polname != NULL)
                        ereport(ERROR,
                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                                 errmsg("target row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
                                        wco->polname, wco->relname)));
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                                 errmsg("target row violates row-level security policy (USING expression) for table \"%s\"",
                                        wco->relname)));
                    break;
                case WCO_RLS_CONFLICT_CHECK:
                    if (wco->polname != NULL)
                        ereport(ERROR,
                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                                 errmsg("new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
                                        wco->polname, wco->relname)));
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                                 errmsg("new row violates row-level security policy (USING expression) for table \"%s\"",
                                        wco->relname)));
                    break;
                default:
                    elog(ERROR, "unrecognized WCO kind: %u", wco->kind);
                    break;
            }
        }
    }
}

References bms_union(), build_attrmap_by_name_if_req(), ExprContext::ecxt_scantuple, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, ExecBuildSlotValueDescription(), ExecGetInsertedCols(), ExecGetUpdatedCols(), ExecQual(), execute_attr_map_slot(), forboth, GetPerTupleExprContext, WithCheckOption::kind, lfirst, MakeTupleTableSlot(), WithCheckOption::polname, RelationGetDescr, RelationGetRelid, WithCheckOption::relname, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_WithCheckOptionExprs, ResultRelInfo::ri_WithCheckOptions, TTSOpsVirtual, WCO_RLS_CONFLICT_CHECK, WCO_RLS_INSERT_CHECK, WCO_RLS_MERGE_DELETE_CHECK, WCO_RLS_MERGE_UPDATE_CHECK, WCO_RLS_UPDATE_CHECK, and WCO_VIEW_CHECK.

Referenced by ExecBatchInsert(), ExecInsert(), ExecMergeMatched(), ExecOnConflictUpdate(), ExecUpdateAct(), and ExecUpdateEpilogue().

◆ FindTupleHashEntry()

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

Definition at line 379 of file execGrouping.c.

{
    TupleHashEntry entry;
    MemoryContext oldContext;
    MinimalTuple key;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    /* Set up data needed by hash and match functions */
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashexpr;
    hashtable->cur_eq_func = eqcomp;
 
    /* Search the hash table */
    key = NULL;                 /* flag to reference inputslot */
    entry = tuplehash_lookup(hashtable->hashtab, key);
    MemoryContextSwitchTo(oldContext);
 
    return entry;
}

References TupleHashTableData::cur_eq_func, TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, sort-test::key, MemoryContextSwitchTo(), and TupleHashTableData::tempcxt.

Referenced by ExecHashSubPlan().

◆ FreeExecutorState()

void FreeExecutorState ( EState * estate )

Definition at line 193 of file execUtils.c.

{
    /*
     * Shut down and free any remaining ExprContexts.  We do this explicitly
     * to ensure that any remaining shutdown callbacks get called (since they
     * might need to release resources that aren't simply memory within the
     * per-query memory context).
     */
    while (estate->es_exprcontexts)
    {
        /*
         * XXX: seems there ought to be a faster way to implement this than
         * repeated list_delete(), no?
         */
        FreeExprContext((ExprContext *) linitial(estate->es_exprcontexts),
                        true);
        /* FreeExprContext removed the list link for us */
    }
 
    /* release JIT context, if allocated */
    if (estate->es_jit)
    {
        jit_release_context(estate->es_jit);
        estate->es_jit = NULL;
    }
 
    /* release partition directory, if allocated */
    if (estate->es_partition_directory)
    {
        DestroyPartitionDirectory(estate->es_partition_directory);
        estate->es_partition_directory = NULL;
    }
 
    /*
     * Free the per-query memory context, thereby releasing all working
     * memory, including the EState node itself.
     */
    MemoryContextDelete(estate->es_query_cxt);
}

References DestroyPartitionDirectory(), EState::es_exprcontexts, EState::es_jit, EState::es_partition_directory, EState::es_query_cxt, FreeExprContext(), jit_release_context(), linitial, and MemoryContextDelete().

Referenced by afterTriggerInvokeEvents(), ATExecAddColumn(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), compute_index_stats(), CopyFrom(), EvalPlanQualEnd(), evaluate_expr(), ExecuteCallStmt(), ExecuteQuery(), ExecuteTruncateGuts(), ExplainExecuteQuery(), finish_edata(), freestate_cluster(), get_qual_for_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), make_build_data(), operator_predicate_proof(), plpgsql_inline_handler(), plpgsql_xact_cb(), standard_ExecutorEnd(), and validateDomainCheckConstraint().

◆ FreeExprContext()

void FreeExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

Definition at line 418 of file execUtils.c.

{
    EState     *estate;
 
    /* Call any registered callbacks */
    ShutdownExprContext(econtext, isCommit);
    /* And clean up the memory used */
    MemoryContextDelete(econtext->ecxt_per_tuple_memory);
    /* Unlink self from owning EState, if any */
    estate = econtext->ecxt_estate;
    if (estate)
        estate->es_exprcontexts = list_delete_ptr(estate->es_exprcontexts,
                                                  econtext);
    /* And delete the ExprContext node */
    pfree(econtext);
}

References ExprContext::ecxt_estate, ExprContext::ecxt_per_tuple_memory, EState::es_exprcontexts, list_delete_ptr(), MemoryContextDelete(), pfree(), and ShutdownExprContext().

Referenced by FreeExecutorState(), plpgsql_destroy_econtext(), and plpgsql_subxact_cb().

◆ GetAttributeByName()

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

Definition at line 1063 of file execUtils.c.

{
    AttrNumber  attrno;
    Datum       result;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    HeapTupleData tmptup;
    int         i;
 
    if (attname == NULL)
        elog(ERROR, "invalid attribute name");
 
    if (isNull == NULL)
        elog(ERROR, "a NULL isNull pointer was passed");
 
    if (tuple == NULL)
    {
        /* Kinda bogus but compatible with old behavior... */
        *isNull = true;
        return (Datum) 0;
    }
 
    tupType = HeapTupleHeaderGetTypeId(tuple);
    tupTypmod = HeapTupleHeaderGetTypMod(tuple);
    tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 
    attrno = InvalidAttrNumber;
    for (i = 0; i < tupDesc->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupDesc, i);
 
        if (namestrcmp(&(att->attname), attname) == 0)
        {
            attrno = att->attnum;
            break;
        }
    }
 
    if (attrno == InvalidAttrNumber)
        elog(ERROR, "attribute \"%s\" does not exist", attname);
 
    /*
     * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
     * the fields in the struct just in case user tries to inspect system
     * columns.
     */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    ItemPointerSetInvalid(&(tmptup.t_self));
    tmptup.t_tableOid = InvalidOid;
    tmptup.t_data = tuple;
 
    result = heap_getattr(&tmptup,
                          attrno,
                          tupDesc,
                          isNull);
 
    ReleaseTupleDesc(tupDesc);
 
    return result;
}

References attname, elog, ERROR, heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), i, InvalidAttrNumber, InvalidOid, ItemPointerSetInvalid(), lookup_rowtype_tupdesc(), namestrcmp(), TupleDescData::natts, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and TupleDescAttr().

Referenced by c_overpaid(), and overpaid().

◆ GetAttributeByNum()

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

Definition at line 1126 of file execUtils.c.

{
    Datum       result;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    HeapTupleData tmptup;
 
    if (!AttributeNumberIsValid(attrno))
        elog(ERROR, "invalid attribute number %d", attrno);
 
    if (isNull == NULL)
        elog(ERROR, "a NULL isNull pointer was passed");
 
    if (tuple == NULL)
    {
        /* Kinda bogus but compatible with old behavior... */
        *isNull = true;
        return (Datum) 0;
    }
 
    tupType = HeapTupleHeaderGetTypeId(tuple);
    tupTypmod = HeapTupleHeaderGetTypMod(tuple);
    tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 
    /*
     * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
     * the fields in the struct just in case user tries to inspect system
     * columns.
     */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    ItemPointerSetInvalid(&(tmptup.t_self));
    tmptup.t_tableOid = InvalidOid;
    tmptup.t_data = tuple;
 
    result = heap_getattr(&tmptup,
                          attrno,
                          tupDesc,
                          isNull);
 
    ReleaseTupleDesc(tupDesc);
 
    return result;
}

References AttributeNumberIsValid, elog, ERROR, heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), InvalidOid, ItemPointerSetInvalid(), lookup_rowtype_tupdesc(), ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

◆ InitResultRelInfo()

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

Definition at line 1326 of file execMain.c.

{
    MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
    resultRelInfo->type = T_ResultRelInfo;
    resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
    resultRelInfo->ri_RelationDesc = resultRelationDesc;
    resultRelInfo->ri_NumIndices = 0;
    resultRelInfo->ri_IndexRelationDescs = NULL;
    resultRelInfo->ri_IndexRelationInfo = NULL;
    resultRelInfo->ri_needLockTagTuple =
        IsInplaceUpdateRelation(resultRelationDesc);
    /* make a copy so as not to depend on relcache info not changing... */
    resultRelInfo->ri_TrigDesc = CopyTriggerDesc(resultRelationDesc->trigdesc);
    if (resultRelInfo->ri_TrigDesc)
    {
        int         n = resultRelInfo->ri_TrigDesc->numtriggers;
 
        resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
            palloc0(n * sizeof(FmgrInfo));
        resultRelInfo->ri_TrigWhenExprs = (ExprState **)
            palloc0(n * sizeof(ExprState *));
        if (instrument_options)
            resultRelInfo->ri_TrigInstrument = InstrAlloc(n, instrument_options, false);
    }
    else
    {
        resultRelInfo->ri_TrigFunctions = NULL;
        resultRelInfo->ri_TrigWhenExprs = NULL;
        resultRelInfo->ri_TrigInstrument = NULL;
    }
    if (resultRelationDesc->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
        resultRelInfo->ri_FdwRoutine = GetFdwRoutineForRelation(resultRelationDesc, true);
    else
        resultRelInfo->ri_FdwRoutine = NULL;
 
    /* The following fields are set later if needed */
    resultRelInfo->ri_RowIdAttNo = 0;
    resultRelInfo->ri_extraUpdatedCols = NULL;
    resultRelInfo->ri_projectNew = NULL;
    resultRelInfo->ri_newTupleSlot = NULL;
    resultRelInfo->ri_oldTupleSlot = NULL;
    resultRelInfo->ri_projectNewInfoValid = false;
    resultRelInfo->ri_FdwState = NULL;
    resultRelInfo->ri_usesFdwDirectModify = false;
    resultRelInfo->ri_ConstraintExprs = NULL;
    resultRelInfo->ri_GeneratedExprsI = NULL;
    resultRelInfo->ri_GeneratedExprsU = NULL;
    resultRelInfo->ri_projectReturning = NULL;
    resultRelInfo->ri_onConflictArbiterIndexes = NIL;
    resultRelInfo->ri_onConflict = NULL;
    resultRelInfo->ri_ReturningSlot = NULL;
    resultRelInfo->ri_TrigOldSlot = NULL;
    resultRelInfo->ri_TrigNewSlot = NULL;
    resultRelInfo->ri_AllNullSlot = NULL;
    resultRelInfo->ri_MergeActions[MERGE_WHEN_MATCHED] = NIL;
    resultRelInfo->ri_MergeActions[MERGE_WHEN_NOT_MATCHED_BY_SOURCE] = NIL;
    resultRelInfo->ri_MergeActions[MERGE_WHEN_NOT_MATCHED_BY_TARGET] = NIL;
    resultRelInfo->ri_MergeJoinCondition = NULL;
 
    /*
     * Only ExecInitPartitionInfo() and ExecInitPartitionDispatchInfo() pass
     * non-NULL partition_root_rri.  For child relations that are part of the
     * initial query rather than being dynamically added by tuple routing,
     * this field is filled in ExecInitModifyTable().
     */
    resultRelInfo->ri_RootResultRelInfo = partition_root_rri;
    /* Set by ExecGetRootToChildMap */
    resultRelInfo->ri_RootToChildMap = NULL;
    resultRelInfo->ri_RootToChildMapValid = false;
    /* Set by ExecInitRoutingInfo */
    resultRelInfo->ri_PartitionTupleSlot = NULL;
    resultRelInfo->ri_ChildToRootMap = NULL;
    resultRelInfo->ri_ChildToRootMapValid = false;
    resultRelInfo->ri_CopyMultiInsertBuffer = NULL;
}

Referenced by create_edata_for_relation(), ExecGetAncestorResultRels(), ExecGetTriggerResultRel(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitResultRelation(), and ExecuteTruncateGuts().

◆ LookupTupleHashEntry()

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

Definition at line 292 of file execGrouping.c.

{
    TupleHashEntry entry;
    MemoryContext oldContext;
    uint32      local_hash;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    /* set up data needed by hash and match functions */
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashtable->tab_hash_expr;
    hashtable->cur_eq_func = hashtable->tab_eq_func;
 
    local_hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
    entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, local_hash);
 
    if (hash != NULL)
        *hash = local_hash;
 
    Assert(entry == NULL || entry->hash == local_hash);
 
    MemoryContextSwitchTo(oldContext);
 
    return entry;
}

References Assert(), TupleHashTableData::cur_eq_func, hash(), TupleHashEntryData::hash, TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, LookupTupleHashEntry_internal(), MemoryContextSwitchTo(), TupleHashTableData::tab_eq_func, TupleHashTableData::tab_hash_expr, TupleHashTableData::tempcxt, and TupleHashTableHash_internal().

Referenced by buildSubPlanHash(), ExecRecursiveUnion(), lookup_hash_entries(), and setop_fill_hash_table().

◆ LookupTupleHashEntryHash()

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

Definition at line 347 of file execGrouping.c.

{
    TupleHashEntry entry;
    MemoryContext oldContext;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    /* set up data needed by hash and match functions */
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashtable->tab_hash_expr;
    hashtable->cur_eq_func = hashtable->tab_eq_func;
 
    entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, hash);
    Assert(entry == NULL || entry->hash == hash);
 
    MemoryContextSwitchTo(oldContext);
 
    return entry;
}

References Assert(), TupleHashTableData::cur_eq_func, hash(), TupleHashEntryData::hash, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, LookupTupleHashEntry_internal(), MemoryContextSwitchTo(), TupleHashTableData::tab_eq_func, TupleHashTableData::tab_hash_expr, and TupleHashTableData::tempcxt.

Referenced by agg_refill_hash_table().

◆ MakePerTupleExprContext()

ExprContext * MakePerTupleExprContext ( EState * estate )

Definition at line 460 of file execUtils.c.

{
    if (estate->es_per_tuple_exprcontext == NULL)
        estate->es_per_tuple_exprcontext = CreateExprContext(estate);
 
    return estate->es_per_tuple_exprcontext;
}

References CreateExprContext(), and EState::es_per_tuple_exprcontext.

◆ MultiExecProcNode()

Node * MultiExecProcNode ( PlanState * node )

Definition at line 507 of file execProcnode.c.

{
    Node       *result;
 
    check_stack_depth();
 
    CHECK_FOR_INTERRUPTS();
 
    if (node->chgParam != NULL) /* something changed */
        ExecReScan(node);       /* let ReScan handle this */
 
    switch (nodeTag(node))
    {
            /*
             * Only node types that actually support multiexec will be listed
             */
 
        case T_HashState:
            result = MultiExecHash((HashState *) node);
            break;
 
        case T_BitmapIndexScanState:
            result = MultiExecBitmapIndexScan((BitmapIndexScanState *) node);
            break;
 
        case T_BitmapAndState:
            result = MultiExecBitmapAnd((BitmapAndState *) node);
            break;
 
        case T_BitmapOrState:
            result = MultiExecBitmapOr((BitmapOrState *) node);
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
            result = NULL;
            break;
    }
 
    return result;
}

References CHECK_FOR_INTERRUPTS, check_stack_depth(), PlanState::chgParam, elog, ERROR, ExecReScan(), MultiExecBitmapAnd(), MultiExecBitmapIndexScan(), MultiExecBitmapOr(), MultiExecHash(), and nodeTag.

Referenced by BitmapTableScanSetup(), ExecHashJoinImpl(), MultiExecBitmapAnd(), and MultiExecBitmapOr().

◆ RegisterExprContextCallback()

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

Definition at line 965 of file execUtils.c.

{
    ExprContext_CB *ecxt_callback;
 
    /* Save the info in appropriate memory context */
    ecxt_callback = (ExprContext_CB *)
        MemoryContextAlloc(econtext->ecxt_per_query_memory,
                           sizeof(ExprContext_CB));
 
    ecxt_callback->function = function;
    ecxt_callback->arg = arg;
 
    /* link to front of list for appropriate execution order */
    ecxt_callback->next = econtext->ecxt_callbacks;
    econtext->ecxt_callbacks = ecxt_callback;
}

References arg, ExprContext_CB::arg, ExprContext::ecxt_callbacks, ExprContext::ecxt_per_query_memory, function, ExprContext_CB::function, MemoryContextAlloc(), and ExprContext_CB::next.

Referenced by AggRegisterCallback(), ExecMakeFunctionResultSet(), ExecPrepareTuplestoreResult(), fmgr_sql(), and init_MultiFuncCall().

◆ RelationFindReplTupleByIndex()

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

Definition at line 179 of file execReplication.c.

{
    ScanKeyData skey[INDEX_MAX_KEYS];
    int         skey_attoff;
    IndexScanDesc scan;
    SnapshotData snap;
    TransactionId xwait;
    Relation    idxrel;
    bool        found;
    TypeCacheEntry **eq = NULL;
    bool        isIdxSafeToSkipDuplicates;
 
    /* Open the index. */
    idxrel = index_open(idxoid, RowExclusiveLock);
 
    isIdxSafeToSkipDuplicates = (GetRelationIdentityOrPK(rel) == idxoid);
 
    InitDirtySnapshot(snap);
 
    /* Build scan key. */
    skey_attoff = build_replindex_scan_key(skey, rel, idxrel, searchslot);
 
    /* Start an index scan. */
    scan = index_beginscan(rel, idxrel, &snap, NULL, skey_attoff, 0);
 
retry:
    found = false;
 
    index_rescan(scan, skey, skey_attoff, NULL, 0);
 
    /* Try to find the tuple */
    while (index_getnext_slot(scan, ForwardScanDirection, outslot))
    {
        /*
         * Avoid expensive equality check if the index is primary key or
         * replica identity index.
         */
        if (!isIdxSafeToSkipDuplicates)
        {
            if (eq == NULL)
                eq = palloc0(sizeof(*eq) * outslot->tts_tupleDescriptor->natts);
 
            if (!tuples_equal(outslot, searchslot, eq))
                continue;
        }
 
        ExecMaterializeSlot(outslot);
 
        xwait = TransactionIdIsValid(snap.xmin) ?
            snap.xmin : snap.xmax;
 
        /*
         * If the tuple is locked, wait for locking transaction to finish and
         * retry.
         */
        if (TransactionIdIsValid(xwait))
        {
            XactLockTableWait(xwait, NULL, NULL, XLTW_None);
            goto retry;
        }
 
        /* Found our tuple and it's not locked */
        found = true;
        break;
    }
 
    /* Found tuple, try to lock it in the lockmode. */
    if (found)
    {
        TM_FailureData tmfd;
        TM_Result   res;
 
        PushActiveSnapshot(GetLatestSnapshot());
 
        res = table_tuple_lock(rel, &(outslot->tts_tid), GetActiveSnapshot(),
                               outslot,
                               GetCurrentCommandId(false),
                               lockmode,
                               LockWaitBlock,
                               0 /* don't follow updates */ ,
                               &tmfd);
 
        PopActiveSnapshot();
 
        if (should_refetch_tuple(res, &tmfd))
            goto retry;
    }
 
    index_endscan(scan);
 
    /* Don't release lock until commit. */
    index_close(idxrel, NoLock);
 
    return found;
}

References build_replindex_scan_key(), ExecMaterializeSlot(), ForwardScanDirection, GetActiveSnapshot(), GetCurrentCommandId(), GetLatestSnapshot(), GetRelationIdentityOrPK(), index_beginscan(), index_close(), index_endscan(), index_getnext_slot(), INDEX_MAX_KEYS, index_open(), index_rescan(), InitDirtySnapshot, LockWaitBlock, TupleDescData::natts, NoLock, palloc0(), PopActiveSnapshot(), PushActiveSnapshot(), RowExclusiveLock, should_refetch_tuple(), table_tuple_lock(), TransactionIdIsValid, TupleTableSlot::tts_tid, TupleTableSlot::tts_tupleDescriptor, tuples_equal(), XactLockTableWait(), XLTW_None, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by FindReplTupleInLocalRel().

◆ RelationFindReplTupleSeq()

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

Definition at line 355 of file execReplication.c.

{
    TupleTableSlot *scanslot;
    TableScanDesc scan;
    SnapshotData snap;
    TypeCacheEntry **eq;
    TransactionId xwait;
    bool        found;
    TupleDesc   desc PG_USED_FOR_ASSERTS_ONLY = RelationGetDescr(rel);
 
    Assert(equalTupleDescs(desc, outslot->tts_tupleDescriptor));
 
    eq = palloc0(sizeof(*eq) * outslot->tts_tupleDescriptor->natts);
 
    /* Start a heap scan. */
    InitDirtySnapshot(snap);
    scan = table_beginscan(rel, &snap, 0, NULL);
    scanslot = table_slot_create(rel, NULL);
 
retry:
    found = false;
 
    table_rescan(scan, NULL);
 
    /* Try to find the tuple */
    while (table_scan_getnextslot(scan, ForwardScanDirection, scanslot))
    {
        if (!tuples_equal(scanslot, searchslot, eq))
            continue;
 
        found = true;
        ExecCopySlot(outslot, scanslot);
 
        xwait = TransactionIdIsValid(snap.xmin) ?
            snap.xmin : snap.xmax;
 
        /*
         * If the tuple is locked, wait for locking transaction to finish and
         * retry.
         */
        if (TransactionIdIsValid(xwait))
        {
            XactLockTableWait(xwait, NULL, NULL, XLTW_None);
            goto retry;
        }
 
        /* Found our tuple and it's not locked */
        break;
    }
 
    /* Found tuple, try to lock it in the lockmode. */
    if (found)
    {
        TM_FailureData tmfd;
        TM_Result   res;
 
        PushActiveSnapshot(GetLatestSnapshot());
 
        res = table_tuple_lock(rel, &(outslot->tts_tid), GetActiveSnapshot(),
                               outslot,
                               GetCurrentCommandId(false),
                               lockmode,
                               LockWaitBlock,
                               0 /* don't follow updates */ ,
                               &tmfd);
 
        PopActiveSnapshot();
 
        if (should_refetch_tuple(res, &tmfd))
            goto retry;
    }
 
    table_endscan(scan);
    ExecDropSingleTupleTableSlot(scanslot);
 
    return found;
}

References Assert(), equalTupleDescs(), ExecCopySlot(), ExecDropSingleTupleTableSlot(), ForwardScanDirection, GetActiveSnapshot(), GetCurrentCommandId(), GetLatestSnapshot(), InitDirtySnapshot, LockWaitBlock, TupleDescData::natts, palloc0(), PG_USED_FOR_ASSERTS_ONLY, PopActiveSnapshot(), PushActiveSnapshot(), RelationGetDescr, should_refetch_tuple(), table_beginscan(), table_endscan(), table_rescan(), table_scan_getnextslot(), table_slot_create(), table_tuple_lock(), TransactionIdIsValid, TupleTableSlot::tts_tid, TupleTableSlot::tts_tupleDescriptor, tuples_equal(), XactLockTableWait(), XLTW_None, SnapshotData::xmax, and SnapshotData::xmin.

Referenced by FindReplTupleInLocalRel().

◆ ReScanExprContext()

void ReScanExprContext ( ExprContext * econtext )

Definition at line 445 of file execUtils.c.

{
    /* Call any registered callbacks */
    ShutdownExprContext(econtext, true);
    /* And clean up the memory used */
    MemoryContextReset(econtext->ecxt_per_tuple_memory);
}

References ExprContext::ecxt_per_tuple_memory, MemoryContextReset(), and ShutdownExprContext().

Referenced by agg_refill_hash_table(), agg_retrieve_direct(), domain_check_input(), ExecEndAgg(), ExecReScan(), ExecReScanAgg(), and ValuesNext().

◆ ResetTupleHashTable()

void ResetTupleHashTable ( TupleHashTable hashtable )

Definition at line 271 of file execGrouping.c.

{
    tuplehash_reset(hashtable->hashtab);
}

References TupleHashTableData::hashtab.

Referenced by agg_refill_hash_table(), build_hash_tables(), buildSubPlanHash(), ExecReScanRecursiveUnion(), and ExecReScanSetOp().

◆ standard_ExecutorEnd()

void standard_ExecutorEnd ( QueryDesc * queryDesc )

Definition at line 544 of file execMain.c.

{
    EState     *estate;
    MemoryContext oldcontext;
 
    /* sanity checks */
    Assert(queryDesc != NULL);
 
    estate = queryDesc->estate;
 
    Assert(estate != NULL);
 
    if (estate->es_parallel_workers_to_launch > 0)
        pgstat_update_parallel_workers_stats((PgStat_Counter) estate->es_parallel_workers_to_launch,
                                             (PgStat_Counter) estate->es_parallel_workers_launched);
 
    /*
     * Check that ExecutorFinish was called, unless in EXPLAIN-only mode or if
     * execution was aborted.
     */
    Assert(estate->es_finished || estate->es_aborted ||
           (estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
 
    /*
     * Switch into per-query memory context to run ExecEndPlan
     */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    ExecEndPlan(queryDesc->planstate, estate);
 
    /* do away with our snapshots */
    UnregisterSnapshot(estate->es_snapshot);
    UnregisterSnapshot(estate->es_crosscheck_snapshot);
 
    /*
     * Reset AFTER trigger module if the query execution was aborted.
     */
    if (estate->es_aborted &&
        !(estate->es_top_eflags &
          (EXEC_FLAG_SKIP_TRIGGERS | EXEC_FLAG_EXPLAIN_ONLY)))
        AfterTriggerAbortQuery();
 
    /*
     * Must switch out of context before destroying it
     */
    MemoryContextSwitchTo(oldcontext);
 
    /*
     * Release EState and per-query memory context.  This should release
     * everything the executor has allocated.
     */
    FreeExecutorState(estate);
 
    /* Reset queryDesc fields that no longer point to anything */
    queryDesc->tupDesc = NULL;
    queryDesc->estate = NULL;
    queryDesc->planstate = NULL;
    queryDesc->totaltime = NULL;
}

References AfterTriggerAbortQuery(), Assert(), EState::es_aborted, EState::es_crosscheck_snapshot, EState::es_finished, EState::es_parallel_workers_launched, EState::es_parallel_workers_to_launch, EState::es_query_cxt, EState::es_snapshot, EState::es_top_eflags, QueryDesc::estate, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_SKIP_TRIGGERS, ExecEndPlan(), FreeExecutorState(), MemoryContextSwitchTo(), pgstat_update_parallel_workers_stats(), QueryDesc::planstate, QueryDesc::totaltime, QueryDesc::tupDesc, and UnregisterSnapshot().

Referenced by ExecutorEnd(), explain_ExecutorEnd(), and pgss_ExecutorEnd().

◆ standard_ExecutorFinish()

void standard_ExecutorFinish ( QueryDesc * queryDesc )

Definition at line 481 of file execMain.c.

{
    EState     *estate;
    MemoryContext oldcontext;
 
    /* sanity checks */
    Assert(queryDesc != NULL);
 
    estate = queryDesc->estate;
 
    Assert(estate != NULL);
    Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
 
    /*
     * This should be run once and only once per Executor instance and never
     * if the execution was aborted.
     */
    Assert(!estate->es_finished && !estate->es_aborted);
 
    /* Switch into per-query memory context */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    /* Allow instrumentation of Executor overall runtime */
    if (queryDesc->totaltime)
        InstrStartNode(queryDesc->totaltime);
 
    /* Run ModifyTable nodes to completion */
    ExecPostprocessPlan(estate);
 
    /* Execute queued AFTER triggers, unless told not to */
    if (!(estate->es_top_eflags & EXEC_FLAG_SKIP_TRIGGERS))
        AfterTriggerEndQuery(estate);
 
    if (queryDesc->totaltime)
        InstrStopNode(queryDesc->totaltime, 0);
 
    MemoryContextSwitchTo(oldcontext);
 
    estate->es_finished = true;
}

References AfterTriggerEndQuery(), Assert(), EState::es_aborted, EState::es_finished, EState::es_query_cxt, EState::es_top_eflags, QueryDesc::estate, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_SKIP_TRIGGERS, ExecPostprocessPlan(), InstrStartNode(), InstrStopNode(), MemoryContextSwitchTo(), and QueryDesc::totaltime.

Referenced by ExecutorFinish(), explain_ExecutorFinish(), and pgss_ExecutorFinish().

◆ standard_ExecutorRun()

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

Definition at line 372 of file execMain.c.

{
    EState     *estate;
    CmdType     operation;
    DestReceiver *dest;
    bool        sendTuples;
    MemoryContext oldcontext;
 
    /* sanity checks */
    Assert(queryDesc != NULL);
 
    estate = queryDesc->estate;
 
    Assert(estate != NULL);
    Assert(!estate->es_aborted);
    Assert(!(estate->es_top_eflags & EXEC_FLAG_EXPLAIN_ONLY));
 
    /* caller must ensure the query's snapshot is active */
    Assert(GetActiveSnapshot() == estate->es_snapshot);
 
    /*
     * Switch into per-query memory context
     */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    /* Allow instrumentation of Executor overall runtime */
    if (queryDesc->totaltime)
        InstrStartNode(queryDesc->totaltime);
 
    /*
     * extract information from the query descriptor and the query feature.
     */
    operation = queryDesc->operation;
    dest = queryDesc->dest;
 
    /*
     * startup tuple receiver, if we will be emitting tuples
     */
    estate->es_processed = 0;
 
    sendTuples = (operation == CMD_SELECT ||
                  queryDesc->plannedstmt->hasReturning);
 
    if (sendTuples)
        dest->rStartup(dest, operation, queryDesc->tupDesc);
 
    /*
     * Run plan, unless direction is NoMovement.
     *
     * Note: pquery.c selects NoMovement if a prior call already reached
     * end-of-data in the user-specified fetch direction.  This is important
     * because various parts of the executor can misbehave if called again
     * after reporting EOF.  For example, heapam.c would actually restart a
     * heapscan and return all its data afresh.  There is also some doubt
     * about whether a parallel plan would operate properly if an additional,
     * necessarily non-parallel execution request occurs after completing a
     * parallel execution.  (That case should work, but it's untested.)
     */
    if (!ScanDirectionIsNoMovement(direction))
        ExecutePlan(queryDesc,
                    operation,
                    sendTuples,
                    count,
                    direction,
                    dest);
 
    /*
     * Update es_total_processed to keep track of the number of tuples
     * processed across multiple ExecutorRun() calls.
     */
    estate->es_total_processed += estate->es_processed;
 
    /*
     * shutdown tuple receiver, if we started it
     */
    if (sendTuples)
        dest->rShutdown(dest);
 
    if (queryDesc->totaltime)
        InstrStopNode(queryDesc->totaltime, estate->es_processed);
 
    MemoryContextSwitchTo(oldcontext);
}

References Assert(), CMD_SELECT, generate_unaccent_rules::dest, QueryDesc::dest, EState::es_aborted, EState::es_processed, EState::es_query_cxt, EState::es_snapshot, EState::es_top_eflags, EState::es_total_processed, QueryDesc::estate, EXEC_FLAG_EXPLAIN_ONLY, ExecutePlan(), GetActiveSnapshot(), PlannedStmt::hasReturning, InstrStartNode(), InstrStopNode(), MemoryContextSwitchTo(), QueryDesc::operation, QueryDesc::plannedstmt, ScanDirectionIsNoMovement, QueryDesc::totaltime, and QueryDesc::tupDesc.

Referenced by ExecutorRun(), explain_ExecutorRun(), and pgss_ExecutorRun().

◆ standard_ExecutorStart()

bool standard_ExecutorStart	(	QueryDesc *	queryDesc,
		int	eflags
	)

Definition at line 148 of file execMain.c.

{
    EState     *estate;
    MemoryContext oldcontext;
 
    /* sanity checks: queryDesc must not be started already */
    Assert(queryDesc != NULL);
    Assert(queryDesc->estate == NULL);
 
    /* caller must ensure the query's snapshot is active */
    Assert(GetActiveSnapshot() == queryDesc->snapshot);
 
    /*
     * If the transaction is read-only, we need to check if any writes are
     * planned to non-temporary tables.  EXPLAIN is considered read-only.
     *
     * Don't allow writes in parallel mode.  Supporting UPDATE and DELETE
     * would require (a) storing the combo CID hash in shared memory, rather
     * than synchronizing it just once at the start of parallelism, and (b) an
     * alternative to heap_update()'s reliance on xmax for mutual exclusion.
     * INSERT may have no such troubles, but we forbid it to simplify the
     * checks.
     *
     * We have lower-level defenses in CommandCounterIncrement and elsewhere
     * against performing unsafe operations in parallel mode, but this gives a
     * more user-friendly error message.
     */
    if ((XactReadOnly || IsInParallelMode()) &&
        !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
        ExecCheckXactReadOnly(queryDesc->plannedstmt);
 
    /*
     * Build EState, switch into per-query memory context for startup.
     */
    estate = CreateExecutorState();
    queryDesc->estate = estate;
 
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    /*
     * Fill in external parameters, if any, from queryDesc; and allocate
     * workspace for internal parameters
     */
    estate->es_param_list_info = queryDesc->params;
 
    if (queryDesc->plannedstmt->paramExecTypes != NIL)
    {
        int         nParamExec;
 
        nParamExec = list_length(queryDesc->plannedstmt->paramExecTypes);
        estate->es_param_exec_vals = (ParamExecData *)
            palloc0(nParamExec * sizeof(ParamExecData));
    }
 
    /* We now require all callers to provide sourceText */
    Assert(queryDesc->sourceText != NULL);
    estate->es_sourceText = queryDesc->sourceText;
 
    /*
     * Fill in the query environment, if any, from queryDesc.
     */
    estate->es_queryEnv = queryDesc->queryEnv;
 
    /*
     * If non-read-only query, set the command ID to mark output tuples with
     */
    switch (queryDesc->operation)
    {
        case CMD_SELECT:
 
            /*
             * SELECT FOR [KEY] UPDATE/SHARE and modifying CTEs need to mark
             * tuples
             */
            if (queryDesc->plannedstmt->rowMarks != NIL ||
                queryDesc->plannedstmt->hasModifyingCTE)
                estate->es_output_cid = GetCurrentCommandId(true);
 
            /*
             * A SELECT without modifying CTEs can't possibly queue triggers,
             * so force skip-triggers mode. This is just a marginal efficiency
             * hack, since AfterTriggerBeginQuery/AfterTriggerEndQuery aren't
             * all that expensive, but we might as well do it.
             */
            if (!queryDesc->plannedstmt->hasModifyingCTE)
                eflags |= EXEC_FLAG_SKIP_TRIGGERS;
            break;
 
        case CMD_INSERT:
        case CMD_DELETE:
        case CMD_UPDATE:
        case CMD_MERGE:
            estate->es_output_cid = GetCurrentCommandId(true);
            break;
 
        default:
            elog(ERROR, "unrecognized operation code: %d",
                 (int) queryDesc->operation);
            break;
    }
 
    /*
     * Copy other important information into the EState
     */
    estate->es_snapshot = RegisterSnapshot(queryDesc->snapshot);
    estate->es_crosscheck_snapshot = RegisterSnapshot(queryDesc->crosscheck_snapshot);
    estate->es_top_eflags = eflags;
    estate->es_instrument = queryDesc->instrument_options;
    estate->es_jit_flags = queryDesc->plannedstmt->jitFlags;
 
    /*
     * Set up an AFTER-trigger statement context, unless told not to, or
     * unless it's EXPLAIN-only mode (when ExecutorFinish won't be called).
     */
    if (!(eflags & (EXEC_FLAG_SKIP_TRIGGERS | EXEC_FLAG_EXPLAIN_ONLY)))
        AfterTriggerBeginQuery();
 
    /*
     * Initialize the plan state tree
     */
    InitPlan(queryDesc, eflags);
 
    MemoryContextSwitchTo(oldcontext);
 
    return ExecPlanStillValid(queryDesc->estate);
}

References AfterTriggerBeginQuery(), Assert(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_SELECT, CMD_UPDATE, CreateExecutorState(), QueryDesc::crosscheck_snapshot, elog, ERROR, EState::es_crosscheck_snapshot, EState::es_instrument, EState::es_jit_flags, EState::es_output_cid, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_query_cxt, EState::es_queryEnv, EState::es_snapshot, EState::es_sourceText, EState::es_top_eflags, QueryDesc::estate, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_SKIP_TRIGGERS, ExecCheckXactReadOnly(), ExecPlanStillValid(), GetActiveSnapshot(), GetCurrentCommandId(), PlannedStmt::hasModifyingCTE, InitPlan(), QueryDesc::instrument_options, IsInParallelMode(), PlannedStmt::jitFlags, list_length(), MemoryContextSwitchTo(), NIL, QueryDesc::operation, palloc0(), PlannedStmt::paramExecTypes, QueryDesc::params, QueryDesc::plannedstmt, QueryDesc::queryEnv, RegisterSnapshot(), PlannedStmt::rowMarks, QueryDesc::snapshot, QueryDesc::sourceText, and XactReadOnly.

Referenced by ExecutorStart(), explain_ExecutorStart(), and pgss_ExecutorStart().

◆ TupleHashTableHash()

uint32 TupleHashTableHash	(	TupleHashTable	hashtable,
		TupleTableSlot *	slot
	)

Definition at line 324 of file execGrouping.c.

{
    MemoryContext oldContext;
    uint32      hash;
 
    hashtable->inputslot = slot;
    hashtable->in_hash_expr = hashtable->tab_hash_expr;
 
    /* Need to run the hash functions in short-lived context */
    oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
 
    hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
 
    MemoryContextSwitchTo(oldContext);
 
    return hash;
}

References hash(), TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, MemoryContextSwitchTo(), TupleHashTableData::tab_hash_expr, TupleHashTableData::tempcxt, and TupleHashTableHash_internal().

◆ UnregisterExprContextCallback()

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

Definition at line 991 of file execUtils.c.

{
    ExprContext_CB **prev_callback;
    ExprContext_CB *ecxt_callback;
 
    prev_callback = &econtext->ecxt_callbacks;
 
    while ((ecxt_callback = *prev_callback) != NULL)
    {
        if (ecxt_callback->function == function && ecxt_callback->arg == arg)
        {
            *prev_callback = ecxt_callback->next;
            pfree(ecxt_callback);
        }
        else
            prev_callback = &ecxt_callback->next;
    }
}

References arg, ExprContext_CB::arg, ExprContext::ecxt_callbacks, function, ExprContext_CB::function, ExprContext_CB::next, and pfree().

Referenced by end_MultiFuncCall(), and fmgr_sql().

◆ UpdateChangedParamSet()

void UpdateChangedParamSet	(	PlanState *	node,
		Bitmapset *	newchg
	)

Definition at line 912 of file execUtils.c.

{
    Bitmapset  *parmset;
 
    /*
     * The plan node only depends on params listed in its allParam set. Don't
     * include anything else into its chgParam set.
     */
    parmset = bms_intersect(node->plan->allParam, newchg);
    node->chgParam = bms_join(node->chgParam, parmset);
}

References Plan::allParam, bms_intersect(), bms_join(), PlanState::chgParam, and PlanState::plan.

Referenced by ExecReScan(), ExecReScanAppend(), ExecReScanBitmapAnd(), ExecReScanBitmapOr(), ExecReScanMergeAppend(), and ExecReScanSubqueryScan().

Variable Documentation

◆ ExecutorCheckPerms_hook

PGDLLIMPORT ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook

extern

Definition at line 76 of file execMain.c.

Referenced by _PG_init(), and ExecCheckPermissions().

◆ ExecutorEnd_hook

PGDLLIMPORT ExecutorEnd_hook_type ExecutorEnd_hook

extern

Definition at line 73 of file execMain.c.

Referenced by _PG_init(), and ExecutorEnd().

◆ ExecutorFinish_hook

PGDLLIMPORT ExecutorFinish_hook_type ExecutorFinish_hook

extern

Definition at line 72 of file execMain.c.

Referenced by _PG_init(), and ExecutorFinish().

◆ ExecutorRun_hook

PGDLLIMPORT ExecutorRun_hook_type ExecutorRun_hook

extern

Definition at line 71 of file execMain.c.

Referenced by _PG_init(), and ExecutorRun().

◆ ExecutorStart_hook

PGDLLIMPORT ExecutorStart_hook_type ExecutorStart_hook

extern

Definition at line 70 of file execMain.c.

Referenced by _PG_init(), and ExecutorStart().

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

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

◆ ExecBuildHash32Expr()

◆ ExecBuildHash32FromAttrs()

◆ ExecBuildParamSetEqual()

◆ ExecBuildProjectionInfo()

◆ ExecBuildSlotValueDescription()

◆ ExecBuildUpdateProjection()

◆ ExecCheck()

◆ ExecCheckIndexConstraints()

◆ ExecCheckPermissions()

◆ ExecCleanTargetListLength()

◆ ExecCleanTypeFromTL()

◆ ExecCloseIndices()

◆ ExecCloseRangeTableRelations()

◆ ExecCloseResultRelations()

◆ ExecConditionalAssignProjectionInfo()

◆ ExecConstraints()

◆ ExecCreateScanSlotFromOuterPlan()

◆ execCurrentOf()

◆ ExecEndNode()

◆ ExecEvalExpr()

◆ ExecEvalExprNoReturn()