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

Include dependency graph for executor.h:

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

Go to the source code of this file.

Data Structures
struct	TupOutputState

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

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

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

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

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

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

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

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

#define	do_text_output_oneline(tstate, str_to_emit)

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

#define	GetPerTupleExprContext(estate)

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

#define	ResetPerTupleExprContext(estate)

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

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

typedef void(*	ExecutorFinish_hook_type) (QueryDesc *queryDesc)

typedef void(*	ExecutorEnd_hook_type) (QueryDesc *queryDesc)

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

typedef TupleTableSlot (	ExecScanAccessMtd) (ScanState *node)

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

typedef struct TupOutputState	TupOutputState

Functions
void	ExecReScan (PlanState *node)

void	ExecMarkPos (PlanState *node)

void	ExecRestrPos (PlanState *node)

bool	ExecSupportsMarkRestore (struct Path *pathnode)

bool	ExecSupportsBackwardScan (Plan *node)

bool	ExecMaterializesOutput (NodeTag plantype)

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

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

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

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

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

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

uint32	TupleHashTableHash (TupleHashTable hashtable, TupleTableSlot *slot)

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

TupleHashEntry	FindTupleHashEntry (TupleHashTable hashtable, TupleTableSlot slot, ExprState eqcomp, 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)

void	ExecutorStart (QueryDesc *queryDesc, int eflags)

void	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 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 Datum	ExecEvalExprSwitchContext (ExprState state, ExprContext econtext, bool *isNull)

static TupleTableSlot *	ExecProject (ProjectionInfo *projInfo)

static bool	ExecQual (ExprState state, ExprContext econtext)

static bool	ExecQualAndReset (ExprState state, ExprContext econtext)

bool	ExecCheck (ExprState state, ExprContext econtext)

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

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

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

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

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

void	ExecAssignScanProjectionInfo (ScanState *node)

void	ExecAssignScanProjectionInfoWithVarno (ScanState *node, int varno)

void	ExecScanReScan (ScanState *node)

void	ExecInitResultTypeTL (PlanState *planstate)

void	ExecInitResultSlot (PlanState planstate, const TupleTableSlotOps tts_ops)

void	ExecInitResultTupleSlotTL (PlanState planstate, const TupleTableSlotOps tts_ops)

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

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

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

TupleDesc	ExecTypeFromTL (List *targetList)

TupleDesc	ExecCleanTypeFromTL (List *targetList)

TupleDesc	ExecTypeFromExprList (List *exprList)

void	ExecTypeSetColNames (TupleDesc typeInfo, List *namesList)

void	UpdateChangedParamSet (PlanState node, Bitmapset newchg)

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

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

void	do_text_output_multiline (TupOutputState tstate, const char txt)

void	end_tup_output (TupOutputState *tstate)

EState *	CreateExecutorState (void)

void	FreeExecutorState (EState *estate)

ExprContext *	CreateExprContext (EState *estate)

ExprContext *	CreateWorkExprContext (EState *estate)

ExprContext *	CreateStandaloneExprContext (void)

void	FreeExprContext (ExprContext *econtext, bool isCommit)

void	ReScanExprContext (ExprContext *econtext)

ExprContext *	MakePerTupleExprContext (EState *estate)

void	ExecAssignExprContext (EState estate, PlanState planstate)

TupleDesc	ExecGetResultType (PlanState *planstate)

const TupleTableSlotOps *	ExecGetResultSlotOps (PlanState planstate, bool isfixed)

void	ExecAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc)

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

void	ExecAssignScanType (ScanState *scanstate, TupleDesc tupDesc)

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

bool	ExecRelationIsTargetRelation (EState *estate, Index scanrelid)

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

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

void	ExecCloseRangeTableRelations (EState *estate)

void	ExecCloseResultRelations (EState *estate)

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

Relation	ExecGetRangeTableRelation (EState *estate, Index rti)

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

int	executor_errposition (EState *estate, int location)

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

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

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

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

int	ExecTargetListLength (List *targetlist)

int	ExecCleanTargetListLength (List *targetlist)

TupleTableSlot *	ExecGetTriggerOldSlot (EState estate, ResultRelInfo relInfo)

TupleTableSlot *	ExecGetTriggerNewSlot (EState estate, ResultRelInfo relInfo)

TupleTableSlot *	ExecGetReturningSlot (EState estate, ResultRelInfo relInfo)

TupleConversionMap *	ExecGetChildToRootMap (ResultRelInfo *resultRelInfo)

TupleConversionMap *	ExecGetRootToChildMap (ResultRelInfo resultRelInfo, EState estate)

Oid	ExecGetResultRelCheckAsUser (ResultRelInfo relInfo, EState estate)

Bitmapset *	ExecGetInsertedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetUpdatedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetExtraUpdatedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetAllUpdatedCols (ResultRelInfo relinfo, EState estate)

void	ExecOpenIndices (ResultRelInfo *resultRelInfo, bool speculative)

void	ExecCloseIndices (ResultRelInfo *resultRelInfo)

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

bool	ExecCheckIndexConstraints (ResultRelInfo resultRelInfo, TupleTableSlot slot, EState estate, ItemPointer conflictTid, 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)

StrategyNumber	get_equal_strategy_number (Oid opclass)

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

◆ EvalPlanQualSetSlot

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

Definition at line 247 of file executor.h.

◆ EXEC_FLAG_BACKWARD

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

Definition at line 68 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_GENERIC

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

Definition at line 66 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_ONLY

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

Definition at line 65 of file executor.h.

◆ EXEC_FLAG_MARK

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

Definition at line 69 of file executor.h.

◆ EXEC_FLAG_REWIND

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

Definition at line 67 of file executor.h.

◆ EXEC_FLAG_SKIP_TRIGGERS

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

Definition at line 70 of file executor.h.

◆ EXEC_FLAG_WITH_NO_DATA

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

Definition at line 71 of file executor.h.

◆ GetPerTupleExprContext

#define GetPerTupleExprContext ( estate )

Value:

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

Definition at line 568 of file executor.h.

◆ GetPerTupleMemoryContext

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

Definition at line 573 of file executor.h.

◆ ResetExprContext

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

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

Typedef Documentation

◆ ExecScanAccessMtd

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

Definition at line 491 of file executor.h.

◆ ExecScanRecheckMtd

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

Definition at line 492 of file executor.h.

◆ ExecutorCheckPerms_hook_type

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

Definition at line 93 of file executor.h.

◆ ExecutorEnd_hook_type

typedef void(* ExecutorEnd_hook_type) (QueryDesc *queryDesc)

Definition at line 89 of file executor.h.

◆ ExecutorFinish_hook_type

typedef void(* ExecutorFinish_hook_type) (QueryDesc *queryDesc)

Definition at line 85 of file executor.h.

◆ ExecutorRun_hook_type

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

Definition at line 79 of file executor.h.

◆ ExecutorStart_hook_type

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

Definition at line 75 of file executor.h.

◆ TupOutputState

typedef struct TupOutputState TupOutputState

Function Documentation

◆ begin_tup_output_tupdesc()

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

Definition at line 2342 of file execTuples.c.

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

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

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

◆ BuildTupleHashTable()

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

Definition at line 264 of file execGrouping.c.

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

References BuildTupleHashTableExt().

◆ BuildTupleHashTableExt()

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

Definition at line 155 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->entrysize = entrysize;
     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 old reset interface is used (i.e. BuildTupleHashTable, rather
      * than BuildTupleHashTableExt), allowing JIT would lead to the generated
      * functions to a) live longer than the query b) be re-generated each time
      * the table is being reset. Therefore prevent JIT from being used in that
      * case, by not providing a parent node (which prevents accessing the
      * JitContext in the EState).
      */
     allow_jit = metacxt != tablecxt;
  
     /* build hash ExprState for all columns */
     hashtable->tab_hash_expr = ExecBuildHash32FromAttrs(inputDesc,
                                                         &TTSOpsMinimalTuple,
                                                         hashfunctions,
                                                         collations,
                                                         numCols,
                                                         keyColIdx,
                                                         allow_jit ? parent : NULL,
                                                         hash_iv);
  
     /* build comparator for all columns */
     /* XXX: should we support non-minimal tuples for the inputslot? */
     hashtable->tab_eq_func = ExecBuildGroupingEqual(inputDesc, inputDesc,
                                                     &TTSOpsMinimalTuple, &TTSOpsMinimalTuple,
                                                     numCols,
                                                     keyColIdx, eqfuncoids, collations,
                                                     allow_jit ? parent : NULL);
  
     /*
      * While not pretty, it's ok to not shut down this context, but instead
      * rely on the containing memory context being reset, as
      * ExecBuildGroupingEqual() only builds a very simple expression calling
      * functions (i.e. nothing that'd employ RegisterExprContextCallback()).
      */
     hashtable->exprcontext = CreateStandaloneExprContext();
  
     MemoryContextSwitchTo(oldcontext);
  
     return hashtable;
 }

References Assert, CreateStandaloneExprContext(), CreateTupleDescCopy(), TupleHashTableData::cur_eq_func, TupleHashTableData::entrysize, ExecBuildGroupingEqual(), ExecBuildHash32FromAttrs(), TupleHashTableData::exprcontext, get_hash_memory_limit(), TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, TupleHashTableData::keyColIdx, MakeSingleTupleTableSlot(), MemoryContextSwitchTo(), murmurhash32(), TupleHashTableData::numCols, palloc(), ParallelWorkerNumber, TupleHashTableData::tab_collations, TupleHashTableData::tab_eq_func, TupleHashTableData::tab_hash_expr, TupleHashTableData::tablecxt, TupleHashTableData::tableslot, TupleHashTableData::tempcxt, and TTSOpsMinimalTuple.

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

◆ check_exclusion_constraint()

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

Definition at line 950 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 761 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 871 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 1026 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_junkFilter = NULL;
  
     estate->es_output_cid = (CommandId) 0;
  
     estate->es_result_relations = NULL;
     estate->es_opened_result_relations = NIL;
     estate->es_tuple_routing_result_relations = NIL;
     estate->es_trig_target_relations = NIL;
  
     estate->es_insert_pending_result_relations = NIL;
     estate->es_insert_pending_modifytables = NIL;
  
     estate->es_param_list_info = NULL;
     estate->es_param_exec_vals = NULL;
  
     estate->es_queryEnv = NULL;
  
     estate->es_query_cxt = qcontext;
  
     estate->es_tupleTable = NIL;
  
     estate->es_processed = 0;
     estate->es_total_processed = 0;
  
     estate->es_top_eflags = 0;
     estate->es_instrument = 0;
     estate->es_finished = false;
  
     estate->es_exprcontexts = NIL;
  
     estate->es_subplanstates = NIL;
  
     estate->es_auxmodifytables = NIL;
  
     estate->es_per_tuple_exprcontext = NULL;
  
     estate->es_sourceText = NULL;
  
     estate->es_use_parallel_mode = false;
     estate->es_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_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_per_tuple_exprcontext, EState::es_plannedstmt, EState::es_processed, EState::es_query_cxt, EState::es_queryEnv, EState::es_range_table, EState::es_range_table_size, EState::es_relations, EState::es_result_relations, EState::es_rowmarks, EState::es_rteperminfos, EState::es_snapshot, EState::es_sourceText, EState::es_subplanstates, EState::es_top_eflags, EState::es_total_processed, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, EState::es_tupleTable, EState::es_use_parallel_mode, ForwardScanDirection, InvalidSnapshot, makeNode, MemoryContextSwitchTo(), and NIL.

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

◆ CreateExprContext()

ExprContext* CreateExprContext ( EState * estate )

Definition at line 306 of file execUtils.c.

 {
     return CreateExprContextInternal(estate, ALLOCSET_DEFAULT_SIZES);
 }

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

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

◆ CreateStandaloneExprContext()

ExprContext* CreateStandaloneExprContext ( void )

Definition at line 357 of file execUtils.c.

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

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

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

◆ CreateWorkExprContext()

ExprContext* CreateWorkExprContext ( EState * estate )

Definition at line 321 of file execUtils.c.

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

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

Referenced by ExecInitAgg().

◆ do_text_output_multiline()

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

Definition at line 2390 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 2362 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 2420 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 2479 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 2760 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 2991 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 2635 of file execMain.c.

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

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

Referenced by ExecScanFetch().

◆ EvalPlanQualInit()

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

Definition at line 2548 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 2744 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 2590 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 2607 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 605 of file executor.h.

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

References EState::es_range_table, and list_nth().

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

◆ ExecAssignExprContext()

void ExecAssignExprContext	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 485 of file execUtils.c.

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

References CreateExprContext(), and PlanState::ps_ExprContext.

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

◆ ExecAssignProjectionInfo()

void ExecAssignProjectionInfo	(	PlanState *	planstate,
		TupleDesc	inputDesc
	)

Definition at line 540 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 270 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 283 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 649 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 2409 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 4321 of file execExpr.c.

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

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

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

◆ 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 4156 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;
     ExprEvalPushStep(state, &scratch);
  
     ExecReadyExpr(state);
  
     return state;
 }

References FunctionCallInfoBaseData::args, Assert, ExprEvalStep::d, EEOP_DONE, EEOP_HASHDATUM_FIRST, EEOP_HASHDATUM_FIRST_STRICT, EEOP_HASHDATUM_NEXT32, EEOP_HASHDATUM_NEXT32_STRICT, EEOP_HASHDATUM_SET_INITVAL, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), ExprEvalPushStep(), fmgr_info(), FmgrInfo::fn_addr, forboth, foreach_current_index, ExprEvalStep::hashdatum, ExprEvalStep::hashdatum_initvalue, i, InitFunctionCallInfoData, NullableDatum::isnull, 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 3998 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;
  
         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;
     ExprEvalPushStep(state, &scratch);
  
     ExecReadyExpr(state);
  
     return state;
 }

References FunctionCallInfoBaseData::args, Assert, attnum, ExprEvalStep::d, EEOP_DONE, EEOP_HASHDATUM_FIRST, EEOP_HASHDATUM_NEXT32, EEOP_HASHDATUM_SET_INITVAL, EEOP_INNER_FETCHSOME, EEOP_INNER_VAR, ExecComputeSlotInfo(), ExecReadyExpr(), ExprEvalPushStep(), ExprEvalStep::fetch, FmgrInfo::fn_addr, ExprEvalStep::hashdatum, ExprEvalStep::hashdatum_initvalue, i, InitFunctionCallInfoData, NullableDatum::isnull, makeNode, Max, ExprEvalStep::opcode, palloc(), palloc0(), ExprEvalStep::resnull, ExprEvalStep::resvalue, SizeForFunctionCallInfo, TupleDescAttr, UInt32GetDatum(), NullableDatum::value, and ExprEvalStep::var.

Referenced by BuildTupleHashTableExt(), 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 4478 of file execExpr.c.

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

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

Referenced by ExecInitMemoize().

◆ ExecBuildProjectionInfo()

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

Definition at line 365 of file execExpr.c.

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

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

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

◆ ExecBuildSlotValueDescription()

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

Definition at line 2223 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 (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 525 of file execExpr.c.

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

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

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

◆ ExecCheck()

bool ExecCheck	(	ExprState *	state,
		ExprContext *	econtext
	)

Definition at line 850 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 536 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 579 of file execMain.c.

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

References aclcheck_error(), ACLCHECK_NO_PRIV, Assert, bms_add_member(), bms_is_member(), bms_num_members(), ExecCheckOneRelPerms(), ExecutorCheckPerms_hook, get_rel_name(), get_rel_relkind(), get_relkind_objtype(), getRTEPermissionInfo(), lfirst_node, list_length(), OidIsValid, 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 1121 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 2037 of file execTuples.c.

 {
     return ExecTypeFromTLInternal(targetList, true);
 }

References ExecTypeFromTLInternal().

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

◆ ExecCloseIndices()

void ExecCloseIndices ( ResultRelInfo * resultRelInfo )

Definition at line 236 of file execIndexing.c.

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

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

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

◆ ExecCloseRangeTableRelations()

void ExecCloseRangeTableRelations ( EState * estate )

Definition at line 1583 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 1523 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 560 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 1925 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 661 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 351 of file executor.h.

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

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

◆ ExecEvalExprSwitchContext()

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

inlinestatic

Definition at line 366 of file executor.h.

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

References ExprContext::ecxt_per_tuple_memory, and MemoryContextSwitchTo().

Referenced by advance_aggregates(), calculate_frame_offsets(), compute_expr_stats(), evaluate_expr(), EvaluateParams(), ExecCheck(), ExecHashJoinOuterGetTuple(), ExecParallelHashJoinOuterGetTuple(), ExecParallelHashJoinPartitionOuter(), ExecProject(), 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))
         {

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ do_text_output_oneline

◆ EvalPlanQualSetSlot

◆ EXEC_FLAG_BACKWARD

◆ EXEC_FLAG_EXPLAIN_GENERIC

◆ EXEC_FLAG_EXPLAIN_ONLY

◆ EXEC_FLAG_MARK

◆ EXEC_FLAG_REWIND

◆ EXEC_FLAG_SKIP_TRIGGERS

◆ EXEC_FLAG_WITH_NO_DATA

◆ GetPerTupleExprContext

◆ GetPerTupleMemoryContext

◆ ResetExprContext

◆ ResetPerTupleExprContext

Typedef Documentation

◆ ExecScanAccessMtd

◆ ExecScanRecheckMtd

◆ ExecutorCheckPerms_hook_type

◆ ExecutorEnd_hook_type

◆ ExecutorFinish_hook_type

◆ ExecutorRun_hook_type

◆ ExecutorStart_hook_type

◆ TupOutputState

Function Documentation

◆ begin_tup_output_tupdesc()

◆ BuildTupleHashTable()

◆ BuildTupleHashTableExt()

◆ check_exclusion_constraint()

◆ CheckCmdReplicaIdentity()

◆ CheckSubscriptionRelkind()

◆ CheckValidResultRel()

◆ CreateExecutorState()

◆ CreateExprContext()

◆ CreateStandaloneExprContext()

◆ CreateWorkExprContext()

◆ do_text_output_multiline()

◆ do_tup_output()

◆ end_tup_output()

◆ EvalPlanQual()

◆ EvalPlanQualBegin()

◆ EvalPlanQualEnd()

◆ EvalPlanQualFetchRowMark()

◆ EvalPlanQualInit()

◆ EvalPlanQualNext()

◆ EvalPlanQualSetPlan()

◆ EvalPlanQualSlot()

◆ exec_rt_fetch()

◆ ExecAssignExprContext()

◆ ExecAssignProjectionInfo()

◆ ExecAssignScanProjectionInfo()

◆ ExecAssignScanProjectionInfoWithVarno()

◆ ExecAssignScanType()

◆ ExecBuildAggTrans()

◆ ExecBuildAuxRowMark()

◆ ExecBuildGroupingEqual()

◆ ExecBuildHash32Expr()

◆ ExecBuildHash32FromAttrs()

◆ ExecBuildParamSetEqual()

◆ ExecBuildProjectionInfo()

◆ ExecBuildSlotValueDescription()

◆ ExecBuildUpdateProjection()

◆ ExecCheck()

◆ ExecCheckIndexConstraints()

◆ ExecCheckPermissions()

◆ ExecCleanTargetListLength()

◆ ExecCleanTypeFromTL()

◆ ExecCloseIndices()

◆ ExecCloseRangeTableRelations()

◆ ExecCloseResultRelations()

◆ ExecConditionalAssignProjectionInfo()

◆ ExecConstraints()

◆ ExecCreateScanSlotFromOuterPlan()

◆ execCurrentOf()

◆ ExecEndNode()

◆ ExecEvalExpr()