PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
executor.h File Reference
#include "executor/execdesc.h"
#include "fmgr.h"
#include "nodes/lockoptions.h"
#include "nodes/parsenodes.h"
#include "utils/memutils.h"
#include "utils/plancache.h"
Include dependency graph for executor.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  TupOutputState
 

Macros

#define EXEC_FLAG_EXPLAIN_ONLY   0x0001 /* EXPLAIN, no ANALYZE */
 
#define EXEC_FLAG_EXPLAIN_GENERIC   0x0002 /* EXPLAIN (GENERIC_PLAN) */
 
#define EXEC_FLAG_REWIND   0x0004 /* need efficient rescan */
 
#define EXEC_FLAG_BACKWARD   0x0008 /* need backward scan */
 
#define EXEC_FLAG_MARK   0x0010 /* need mark/restore */
 
#define EXEC_FLAG_SKIP_TRIGGERS   0x0020 /* skip AfterTrigger setup */
 
#define EXEC_FLAG_WITH_NO_DATA   0x0040 /* REFRESH ... WITH NO DATA */
 
#define EvalPlanQualSetSlot(epqstate, slot)   ((epqstate)->origslot = (slot))
 
#define do_text_output_oneline(tstate, str_to_emit)
 
#define ResetExprContext(econtext)    MemoryContextReset((econtext)->ecxt_per_tuple_memory)
 
#define GetPerTupleExprContext(estate)
 
#define GetPerTupleMemoryContext(estate)    (GetPerTupleExprContext(estate)->ecxt_per_tuple_memory)
 
#define ResetPerTupleExprContext(estate)
 

Typedefs

typedef bool(* ExecutorStart_hook_type) (QueryDesc *queryDesc, int eflags)
 
typedef void(* ExecutorRun_hook_type) (QueryDesc *queryDesc, ScanDirection direction, uint64 count)
 
typedef void(* ExecutorFinish_hook_type) (QueryDesc *queryDesc)
 
typedef void(* ExecutorEnd_hook_type) (QueryDesc *queryDesc)
 
typedef bool(* ExecutorCheckPerms_hook_type) (List *rangeTable, List *rtePermInfos, bool ereport_on_violation)
 
typedef TupleTableSlot *(* ExecScanAccessMtd) (ScanState *node)
 
typedef bool(* ExecScanRecheckMtd) (ScanState *node, TupleTableSlot *slot)
 
typedef struct TupOutputState TupOutputState
 

Functions

void ExecReScan (PlanState *node)
 
void ExecMarkPos (PlanState *node)
 
void ExecRestrPos (PlanState *node)
 
bool ExecSupportsMarkRestore (struct Path *pathnode)
 
bool ExecSupportsBackwardScan (Plan *node)
 
bool ExecMaterializesOutput (NodeTag plantype)
 
bool execCurrentOf (CurrentOfExpr *cexpr, ExprContext *econtext, Oid table_oid, ItemPointer current_tid)
 
ExprStateexecTuplesMatchPrepare (TupleDesc desc, int numCols, const AttrNumber *keyColIdx, const Oid *eqOperators, const Oid *collations, PlanState *parent)
 
void execTuplesHashPrepare (int numCols, const Oid *eqOperators, Oid **eqFuncOids, FmgrInfo **hashFunctions)
 
TupleHashTable BuildTupleHashTable (PlanState *parent, TupleDesc inputDesc, const TupleTableSlotOps *inputOps, int numCols, AttrNumber *keyColIdx, const Oid *eqfuncoids, FmgrInfo *hashfunctions, Oid *collations, long nbuckets, Size additionalsize, MemoryContext metacxt, MemoryContext tablecxt, MemoryContext tempcxt, bool use_variable_hash_iv)
 
TupleHashEntry LookupTupleHashEntry (TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 *hash)
 
uint32 TupleHashTableHash (TupleHashTable hashtable, TupleTableSlot *slot)
 
TupleHashEntry LookupTupleHashEntryHash (TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash)
 
TupleHashEntry FindTupleHashEntry (TupleHashTable hashtable, TupleTableSlot *slot, ExprState *eqcomp, ExprState *hashexpr)
 
void ResetTupleHashTable (TupleHashTable hashtable)
 
static size_t TupleHashEntrySize (void)
 
static MinimalTuple TupleHashEntryGetTuple (TupleHashEntry entry)
 
static void * TupleHashEntryGetAdditional (TupleHashTable hashtable, TupleHashEntry entry)
 
JunkFilterExecInitJunkFilter (List *targetList, TupleTableSlot *slot)
 
JunkFilterExecInitJunkFilterConversion (List *targetList, TupleDesc cleanTupType, TupleTableSlot *slot)
 
AttrNumber ExecFindJunkAttribute (JunkFilter *junkfilter, const char *attrName)
 
AttrNumber ExecFindJunkAttributeInTlist (List *targetlist, const char *attrName)
 
TupleTableSlotExecFilterJunk (JunkFilter *junkfilter, TupleTableSlot *slot)
 
static Datum ExecGetJunkAttribute (TupleTableSlot *slot, AttrNumber attno, bool *isNull)
 
bool ExecutorStart (QueryDesc *queryDesc, int eflags)
 
void ExecutorStartCachedPlan (QueryDesc *queryDesc, int eflags, CachedPlanSource *plansource, int query_index)
 
bool standard_ExecutorStart (QueryDesc *queryDesc, int eflags)
 
void ExecutorRun (QueryDesc *queryDesc, ScanDirection direction, uint64 count)
 
void standard_ExecutorRun (QueryDesc *queryDesc, ScanDirection direction, uint64 count)
 
void ExecutorFinish (QueryDesc *queryDesc)
 
void standard_ExecutorFinish (QueryDesc *queryDesc)
 
void ExecutorEnd (QueryDesc *queryDesc)
 
void standard_ExecutorEnd (QueryDesc *queryDesc)
 
void ExecutorRewind (QueryDesc *queryDesc)
 
bool ExecCheckPermissions (List *rangeTable, List *rteperminfos, bool ereport_on_violation)
 
void CheckValidResultRel (ResultRelInfo *resultRelInfo, CmdType operation, List *mergeActions)
 
void InitResultRelInfo (ResultRelInfo *resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo *partition_root_rri, int instrument_options)
 
ResultRelInfoExecGetTriggerResultRel (EState *estate, Oid relid, ResultRelInfo *rootRelInfo)
 
ListExecGetAncestorResultRels (EState *estate, ResultRelInfo *resultRelInfo)
 
void ExecConstraints (ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)
 
AttrNumber ExecRelGenVirtualNotNull (ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, List *notnull_virtual_attrs)
 
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)
 
ExecRowMarkExecFindRowMark (EState *estate, Index rti, bool missing_ok)
 
ExecAuxRowMarkExecBuildAuxRowMark (ExecRowMark *erm, List *targetlist)
 
TupleTableSlotEvalPlanQual (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)
 
TupleTableSlotEvalPlanQualSlot (EPQState *epqstate, Relation relation, Index rti)
 
bool EvalPlanQualFetchRowMark (EPQState *epqstate, Index rti, TupleTableSlot *slot)
 
TupleTableSlotEvalPlanQualNext (EPQState *epqstate)
 
void EvalPlanQualBegin (EPQState *epqstate)
 
void EvalPlanQualEnd (EPQState *epqstate)
 
PlanStateExecInitNode (Plan *node, EState *estate, int eflags)
 
void ExecSetExecProcNode (PlanState *node, ExecProcNodeMtd function)
 
NodeMultiExecProcNode (PlanState *node)
 
void ExecEndNode (PlanState *node)
 
void ExecShutdownNode (PlanState *node)
 
void ExecSetTupleBound (int64 tuples_needed, PlanState *child_node)
 
static bool ExecPlanStillValid (EState *estate)
 
static bool ExecShouldLockRelations (EState *estate)
 
static TupleTableSlotExecProcNode (PlanState *node)
 
ExprStateExecInitExpr (Expr *node, PlanState *parent)
 
ExprStateExecInitExprWithParams (Expr *node, ParamListInfo ext_params)
 
ExprStateExecInitQual (List *qual, PlanState *parent)
 
ExprStateExecInitCheck (List *qual, PlanState *parent)
 
ListExecInitExprList (List *nodes, PlanState *parent)
 
ExprStateExecBuildAggTrans (AggState *aggstate, struct AggStatePerPhaseData *phase, bool doSort, bool doHash, bool nullcheck)
 
ExprStateExecBuildHash32FromAttrs (TupleDesc desc, const TupleTableSlotOps *ops, FmgrInfo *hashfunctions, Oid *collations, int numCols, AttrNumber *keyColIdx, PlanState *parent, uint32 init_value)
 
ExprStateExecBuildHash32Expr (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)
 
ExprStateExecBuildGroupingEqual (TupleDesc ldesc, TupleDesc rdesc, const TupleTableSlotOps *lops, const TupleTableSlotOps *rops, int numCols, const AttrNumber *keyColIdx, const Oid *eqfunctions, const Oid *collations, PlanState *parent)
 
ExprStateExecBuildParamSetEqual (TupleDesc desc, const TupleTableSlotOps *lops, const TupleTableSlotOps *rops, const Oid *eqfunctions, const Oid *collations, const List *param_exprs, PlanState *parent)
 
ProjectionInfoExecBuildProjectionInfo (List *targetList, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent, TupleDesc inputDesc)
 
ProjectionInfoExecBuildUpdateProjection (List *targetList, bool evalTargetList, List *targetColnos, TupleDesc relDesc, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent)
 
ExprStateExecPrepareExpr (Expr *node, EState *estate)
 
ExprStateExecPrepareQual (List *qual, EState *estate)
 
ExprStateExecPrepareCheck (List *qual, EState *estate)
 
ListExecPrepareExprList (List *nodes, EState *estate)
 
static Datum ExecEvalExpr (ExprState *state, ExprContext *econtext, bool *isNull)
 
static void ExecEvalExprNoReturn (ExprState *state, ExprContext *econtext)
 
static Datum ExecEvalExprSwitchContext (ExprState *state, ExprContext *econtext, bool *isNull)
 
static void ExecEvalExprNoReturnSwitchContext (ExprState *state, ExprContext *econtext)
 
static TupleTableSlotExecProject (ProjectionInfo *projInfo)
 
static bool ExecQual (ExprState *state, ExprContext *econtext)
 
static bool ExecQualAndReset (ExprState *state, ExprContext *econtext)
 
bool ExecCheck (ExprState *state, ExprContext *econtext)
 
SetExprStateExecInitTableFunctionResult (Expr *expr, ExprContext *econtext, PlanState *parent)
 
TuplestorestateExecMakeTableFunctionResult (SetExprState *setexpr, ExprContext *econtext, MemoryContext argContext, TupleDesc expectedDesc, bool randomAccess)
 
SetExprStateExecInitFunctionResultSet (Expr *expr, ExprContext *econtext, PlanState *parent)
 
Datum ExecMakeFunctionResultSet (SetExprState *fcache, ExprContext *econtext, MemoryContext argContext, bool *isNull, ExprDoneCond *isDone)
 
TupleTableSlotExecScan (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)
 
TupleTableSlotExecInitExtraTupleSlot (EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
 
TupleTableSlotExecInitNullTupleSlot (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)
 
TupOutputStatebegin_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)
 
EStateCreateExecutorState (void)
 
void FreeExecutorState (EState *estate)
 
ExprContextCreateExprContext (EState *estate)
 
ExprContextCreateWorkExprContext (EState *estate)
 
ExprContextCreateStandaloneExprContext (void)
 
void FreeExprContext (ExprContext *econtext, bool isCommit)
 
void ReScanExprContext (ExprContext *econtext)
 
ExprContextMakePerTupleExprContext (EState *estate)
 
void ExecAssignExprContext (EState *estate, PlanState *planstate)
 
TupleDesc ExecGetResultType (PlanState *planstate)
 
const TupleTableSlotOpsExecGetResultSlotOps (PlanState *planstate, bool *isfixed)
 
const TupleTableSlotOpsExecGetCommonSlotOps (PlanState **planstates, int nplans)
 
const TupleTableSlotOpsExecGetCommonChildSlotOps (PlanState *ps)
 
void ExecAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc)
 
void ExecConditionalAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc, int varno)
 
void ExecAssignScanType (ScanState *scanstate, TupleDesc tupDesc)
 
void ExecCreateScanSlotFromOuterPlan (EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)
 
bool ExecRelationIsTargetRelation (EState *estate, Index scanrelid)
 
Relation ExecOpenScanRelation (EState *estate, Index scanrelid, int eflags)
 
void ExecInitRangeTable (EState *estate, List *rangeTable, List *permInfos, Bitmapset *unpruned_relids)
 
void ExecCloseRangeTableRelations (EState *estate)
 
void ExecCloseResultRelations (EState *estate)
 
static RangeTblEntryexec_rt_fetch (Index rti, EState *estate)
 
Relation ExecGetRangeTableRelation (EState *estate, Index rti, bool isResultRel)
 
void ExecInitResultRelation (EState *estate, ResultRelInfo *resultRelInfo, Index rti)
 
int executor_errposition (EState *estate, int location)
 
void RegisterExprContextCallback (ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
 
void UnregisterExprContextCallback (ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
 
Datum GetAttributeByName (HeapTupleHeader tuple, const char *attname, bool *isNull)
 
Datum GetAttributeByNum (HeapTupleHeader tuple, AttrNumber attrno, bool *isNull)
 
int ExecTargetListLength (List *targetlist)
 
int ExecCleanTargetListLength (List *targetlist)
 
TupleTableSlotExecGetTriggerOldSlot (EState *estate, ResultRelInfo *relInfo)
 
TupleTableSlotExecGetTriggerNewSlot (EState *estate, ResultRelInfo *relInfo)
 
TupleTableSlotExecGetReturningSlot (EState *estate, ResultRelInfo *relInfo)
 
TupleTableSlotExecGetAllNullSlot (EState *estate, ResultRelInfo *relInfo)
 
TupleConversionMapExecGetChildToRootMap (ResultRelInfo *resultRelInfo)
 
TupleConversionMapExecGetRootToChildMap (ResultRelInfo *resultRelInfo, EState *estate)
 
Oid ExecGetResultRelCheckAsUser (ResultRelInfo *relInfo, EState *estate)
 
BitmapsetExecGetInsertedCols (ResultRelInfo *relinfo, EState *estate)
 
BitmapsetExecGetUpdatedCols (ResultRelInfo *relinfo, EState *estate)
 
BitmapsetExecGetExtraUpdatedCols (ResultRelInfo *relinfo, EState *estate)
 
BitmapsetExecGetAllUpdatedCols (ResultRelInfo *relinfo, EState *estate)
 
void ExecOpenIndices (ResultRelInfo *resultRelInfo, bool speculative)
 
void ExecCloseIndices (ResultRelInfo *resultRelInfo)
 
ListExecInsertIndexTuples (ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool update, bool noDupErr, bool *specConflict, List *arbiterIndexes, bool onlySummarizing)
 
bool ExecCheckIndexConstraints (ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, ItemPointer conflictTid, ItemPointer tupleid, List *arbiterIndexes)
 
void check_exclusion_constraint (Relation heap, Relation index, IndexInfo *indexInfo, ItemPointer tupleid, const Datum *values, const bool *isnull, EState *estate, bool newIndex)
 
bool RelationFindReplTupleByIndex (Relation rel, Oid idxoid, LockTupleMode lockmode, TupleTableSlot *searchslot, TupleTableSlot *outslot)
 
bool RelationFindReplTupleSeq (Relation rel, LockTupleMode lockmode, TupleTableSlot *searchslot, TupleTableSlot *outslot)
 
void ExecSimpleRelationInsert (ResultRelInfo *resultRelInfo, EState *estate, TupleTableSlot *slot)
 
void ExecSimpleRelationUpdate (ResultRelInfo *resultRelInfo, EState *estate, EPQState *epqstate, TupleTableSlot *searchslot, TupleTableSlot *slot)
 
void ExecSimpleRelationDelete (ResultRelInfo *resultRelInfo, EState *estate, EPQState *epqstate, TupleTableSlot *searchslot)
 
void CheckCmdReplicaIdentity (Relation rel, CmdType cmd)
 
void CheckSubscriptionRelkind (char relkind, const char *nspname, const char *relname)
 
TupleTableSlotExecGetUpdateNewTuple (ResultRelInfo *relinfo, TupleTableSlot *planSlot, TupleTableSlot *oldSlot)
 
ResultRelInfoExecLookupResultRelByOid (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)
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
text * cstring_to_text(const char *s)
Definition: varlena.c:192

Definition at line 650 of file executor.h.

◆ EvalPlanQualSetSlot

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

Definition at line 287 of file executor.h.

◆ EXEC_FLAG_BACKWARD

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

Definition at line 69 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_GENERIC

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

Definition at line 67 of file executor.h.

◆ EXEC_FLAG_EXPLAIN_ONLY

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

Definition at line 66 of file executor.h.

◆ EXEC_FLAG_MARK

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

Definition at line 70 of file executor.h.

◆ EXEC_FLAG_REWIND

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

Definition at line 68 of file executor.h.

◆ EXEC_FLAG_SKIP_TRIGGERS

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

Definition at line 71 of file executor.h.

◆ EXEC_FLAG_WITH_NO_DATA

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

Definition at line 72 of file executor.h.

◆ GetPerTupleExprContext

#define GetPerTupleExprContext (   estate)
Value:
((estate)->es_per_tuple_exprcontext ? \
(estate)->es_per_tuple_exprcontext : \
MakePerTupleExprContext(estate))

Definition at line 678 of file executor.h.

◆ GetPerTupleMemoryContext

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

Definition at line 683 of file executor.h.

◆ ResetExprContext

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

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

Typedef Documentation

◆ ExecScanAccessMtd

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

Definition at line 601 of file executor.h.

◆ ExecScanRecheckMtd

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

Definition at line 602 of file executor.h.

◆ ExecutorCheckPerms_hook_type

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

Definition at line 94 of file executor.h.

◆ ExecutorEnd_hook_type

typedef void(* ExecutorEnd_hook_type) (QueryDesc *queryDesc)

Definition at line 90 of file executor.h.

◆ ExecutorFinish_hook_type

typedef void(* ExecutorFinish_hook_type) (QueryDesc *queryDesc)

Definition at line 86 of file executor.h.

◆ ExecutorRun_hook_type

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

Definition at line 80 of file executor.h.

◆ ExecutorStart_hook_type

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

Definition at line 76 of file executor.h.

◆ TupOutputState

Function Documentation

◆ begin_tup_output_tupdesc()

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

Definition at line 2444 of file execTuples.c.

2447{
2448 TupOutputState *tstate;
2449
2450 tstate = (TupOutputState *) palloc(sizeof(TupOutputState));
2451
2452 tstate->slot = MakeSingleTupleTableSlot(tupdesc, tts_ops);
2453 tstate->dest = dest;
2454
2455 tstate->dest->rStartup(tstate->dest, (int) CMD_SELECT, tupdesc);
2456
2457 return tstate;
2458}
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1427
void * palloc(Size size)
Definition: mcxt.c:1317
@ CMD_SELECT
Definition: nodes.h:271
TupleTableSlot * slot
Definition: executor.h:634
DestReceiver * dest
Definition: executor.h:635
void(* rStartup)(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: dest.h:121

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

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

◆ BuildTupleHashTable()

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

Definition at line 161 of file execGrouping.c.

175{
176 TupleHashTable hashtable;
177 Size entrysize;
178 Size hash_mem_limit;
179 MemoryContext oldcontext;
180 bool allow_jit;
181 uint32 hash_iv = 0;
182
183 Assert(nbuckets > 0);
184 additionalsize = MAXALIGN(additionalsize);
185 entrysize = sizeof(TupleHashEntryData) + additionalsize;
186
187 /* Limit initial table size request to not more than hash_mem */
188 hash_mem_limit = get_hash_memory_limit() / entrysize;
189 if (nbuckets > hash_mem_limit)
190 nbuckets = hash_mem_limit;
191
192 oldcontext = MemoryContextSwitchTo(metacxt);
193
194 hashtable = (TupleHashTable) palloc(sizeof(TupleHashTableData));
195
196 hashtable->numCols = numCols;
197 hashtable->keyColIdx = keyColIdx;
198 hashtable->tab_collations = collations;
199 hashtable->tablecxt = tablecxt;
200 hashtable->tempcxt = tempcxt;
201 hashtable->additionalsize = additionalsize;
202 hashtable->tableslot = NULL; /* will be made on first lookup */
203 hashtable->inputslot = NULL;
204 hashtable->in_hash_expr = NULL;
205 hashtable->cur_eq_func = NULL;
206
207 /*
208 * If parallelism is in use, even if the leader backend is performing the
209 * scan itself, we don't want to create the hashtable exactly the same way
210 * in all workers. As hashtables are iterated over in keyspace-order,
211 * doing so in all processes in the same way is likely to lead to
212 * "unbalanced" hashtables when the table size initially is
213 * underestimated.
214 */
215 if (use_variable_hash_iv)
217
218 hashtable->hashtab = tuplehash_create(metacxt, nbuckets, hashtable);
219
220 /*
221 * We copy the input tuple descriptor just for safety --- we assume all
222 * input tuples will have equivalent descriptors.
223 */
226
227 /*
228 * If the caller fails to make the metacxt different from the tablecxt,
229 * allowing JIT would lead to the generated functions to a) live longer
230 * than the query or b) be re-generated each time the table is being
231 * reset. Therefore prevent JIT from being used in that case, by not
232 * providing a parent node (which prevents accessing the JitContext in the
233 * EState).
234 */
235 allow_jit = (metacxt != tablecxt);
236
237 /* build hash ExprState for all columns */
238 hashtable->tab_hash_expr = ExecBuildHash32FromAttrs(inputDesc,
239 inputOps,
240 hashfunctions,
241 collations,
242 numCols,
243 keyColIdx,
244 allow_jit ? parent : NULL,
245 hash_iv);
246
247 /* build comparator for all columns */
248 hashtable->tab_eq_func = ExecBuildGroupingEqual(inputDesc, inputDesc,
249 inputOps,
251 numCols,
252 keyColIdx, eqfuncoids, collations,
253 allow_jit ? parent : NULL);
254
255 /*
256 * While not pretty, it's ok to not shut down this context, but instead
257 * rely on the containing memory context being reset, as
258 * ExecBuildGroupingEqual() only builds a very simple expression calling
259 * functions (i.e. nothing that'd employ RegisterExprContextCallback()).
260 */
262
263 MemoryContextSwitchTo(oldcontext);
264
265 return hashtable;
266}
int ParallelWorkerNumber
Definition: parallel.c:115
#define MAXALIGN(LEN)
Definition: c.h:782
uint32_t uint32
Definition: c.h:502
size_t Size
Definition: c.h:576
ExprState * ExecBuildHash32FromAttrs(TupleDesc desc, const TupleTableSlotOps *ops, FmgrInfo *hashfunctions, Oid *collations, int numCols, AttrNumber *keyColIdx, PlanState *parent, uint32 init_value)
Definition: execExpr.c:4141
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: execExpr.c:4465
const TupleTableSlotOps TTSOpsMinimalTuple
Definition: execTuples.c:86
ExprContext * CreateStandaloneExprContext(void)
Definition: execUtils.c:358
struct TupleHashTableData * TupleHashTable
Definition: execnodes.h:844
struct TupleHashEntryData TupleHashEntryData
static uint32 murmurhash32(uint32 data)
Definition: hashfn.h:92
Assert(PointerIsAligned(start, uint64))
size_t get_hash_memory_limit(void)
Definition: nodeHash.c:3616
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
AttrNumber * keyColIdx
Definition: execnodes.h:865
tuplehash_hash * hashtab
Definition: execnodes.h:863
ExprState * in_hash_expr
Definition: execnodes.h:875
ExprState * tab_hash_expr
Definition: execnodes.h:866
MemoryContext tempcxt
Definition: execnodes.h:870
ExprState * tab_eq_func
Definition: execnodes.h:867
TupleTableSlot * tableslot
Definition: execnodes.h:872
ExprContext * exprcontext
Definition: execnodes.h:877
MemoryContext tablecxt
Definition: execnodes.h:869
TupleTableSlot * inputslot
Definition: execnodes.h:874
ExprState * cur_eq_func
Definition: execnodes.h:876
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:245

References TupleHashTableData::additionalsize, Assert(), CreateStandaloneExprContext(), CreateTupleDescCopy(), TupleHashTableData::cur_eq_func, ExecBuildGroupingEqual(), ExecBuildHash32FromAttrs(), TupleHashTableData::exprcontext, get_hash_memory_limit(), TupleHashTableData::hashtab, TupleHashTableData::in_hash_expr, TupleHashTableData::inputslot, TupleHashTableData::keyColIdx, MakeSingleTupleTableSlot(), MAXALIGN, 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(), and buildSubPlanHash().

◆ check_exclusion_constraint()

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

Definition at line 957 of file execIndexing.c.

962{
963 (void) check_exclusion_or_unique_constraint(heap, index, indexInfo, tupleid,
964 values, isnull,
965 estate, newIndex,
966 CEOUC_WAIT, false, NULL);
967}
static Datum values[MAXATTR]
Definition: bootstrap.c:151
static bool check_exclusion_or_unique_constraint(Relation heap, Relation index, IndexInfo *indexInfo, ItemPointer tupleid, const Datum *values, const bool *isnull, EState *estate, bool newIndex, CEOUC_WAIT_MODE waitMode, bool violationOK, ItemPointer conflictTid)
Definition: execIndexing.c:705
@ CEOUC_WAIT
Definition: execIndexing.c:124
Definition: type.h:96

References CEOUC_WAIT, check_exclusion_or_unique_constraint(), and values.

Referenced by IndexCheckExclusion().

◆ CheckCmdReplicaIdentity()

void CheckCmdReplicaIdentity ( Relation  rel,
CmdType  cmd 
)

Definition at line 737 of file execReplication.c.

738{
739 PublicationDesc pubdesc;
740
741 /*
742 * Skip checking the replica identity for partitioned tables, because the
743 * operations are actually performed on the leaf partitions.
744 */
745 if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
746 return;
747
748 /* We only need to do checks for UPDATE and DELETE. */
749 if (cmd != CMD_UPDATE && cmd != CMD_DELETE)
750 return;
751
752 /*
753 * It is only safe to execute UPDATE/DELETE if the relation does not
754 * publish UPDATEs or DELETEs, or all the following conditions are
755 * satisfied:
756 *
757 * 1. All columns, referenced in the row filters from publications which
758 * the relation is in, are valid - i.e. when all referenced columns are
759 * part of REPLICA IDENTITY.
760 *
761 * 2. All columns, referenced in the column lists are valid - i.e. when
762 * all columns referenced in the REPLICA IDENTITY are covered by the
763 * column list.
764 *
765 * 3. All generated columns in REPLICA IDENTITY of the relation, are valid
766 * - i.e. when all these generated columns are published.
767 *
768 * XXX We could optimize it by first checking whether any of the
769 * publications have a row filter or column list for this relation, or if
770 * the relation contains a generated column. If none of these exist and
771 * the relation has replica identity then we can avoid building the
772 * descriptor but as this happens only one time it doesn't seem worth the
773 * additional complexity.
774 */
775 RelationBuildPublicationDesc(rel, &pubdesc);
776 if (cmd == CMD_UPDATE && !pubdesc.rf_valid_for_update)
778 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
779 errmsg("cannot update table \"%s\"",
781 errdetail("Column used in the publication WHERE expression is not part of the replica identity.")));
782 else if (cmd == CMD_UPDATE && !pubdesc.cols_valid_for_update)
784 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
785 errmsg("cannot update table \"%s\"",
787 errdetail("Column list used by the publication does not cover the replica identity.")));
788 else if (cmd == CMD_UPDATE && !pubdesc.gencols_valid_for_update)
790 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
791 errmsg("cannot update table \"%s\"",
793 errdetail("Replica identity must not contain unpublished generated columns.")));
794 else if (cmd == CMD_DELETE && !pubdesc.rf_valid_for_delete)
796 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
797 errmsg("cannot delete from table \"%s\"",
799 errdetail("Column used in the publication WHERE expression is not part of the replica identity.")));
800 else if (cmd == CMD_DELETE && !pubdesc.cols_valid_for_delete)
802 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
803 errmsg("cannot delete from table \"%s\"",
805 errdetail("Column list used by the publication does not cover the replica identity.")));
806 else if (cmd == CMD_DELETE && !pubdesc.gencols_valid_for_delete)
808 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
809 errmsg("cannot delete from table \"%s\"",
811 errdetail("Replica identity must not contain unpublished generated columns.")));
812
813 /* If relation has replica identity we are always good. */
815 return;
816
817 /* REPLICA IDENTITY FULL is also good for UPDATE/DELETE. */
818 if (rel->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
819 return;
820
821 /*
822 * This is UPDATE/DELETE and there is no replica identity.
823 *
824 * Check if the table publishes UPDATES or DELETES.
825 */
826 if (cmd == CMD_UPDATE && pubdesc.pubactions.pubupdate)
828 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
829 errmsg("cannot update table \"%s\" because it does not have a replica identity and publishes updates",
831 errhint("To enable updating the table, set REPLICA IDENTITY using ALTER TABLE.")));
832 else if (cmd == CMD_DELETE && pubdesc.pubactions.pubdelete)
834 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
835 errmsg("cannot delete from table \"%s\" because it does not have a replica identity and publishes deletes",
837 errhint("To enable deleting from the table, set REPLICA IDENTITY using ALTER TABLE.")));
838}
#define OidIsValid(objectId)
Definition: c.h:746
int errdetail(const char *fmt,...)
Definition: elog.c:1204
int errhint(const char *fmt,...)
Definition: elog.c:1318
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
@ CMD_DELETE
Definition: nodes.h:274
@ CMD_UPDATE
Definition: nodes.h:272
#define RelationGetRelationName(relation)
Definition: rel.h:550
void RelationBuildPublicationDesc(Relation relation, PublicationDesc *pubdesc)
Definition: relcache.c:5777
Oid RelationGetReplicaIndex(Relation relation)
Definition: relcache.c:5055
PublicationActions pubactions
bool gencols_valid_for_update
bool gencols_valid_for_delete
Form_pg_class rd_rel
Definition: rel.h:111

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 847 of file execReplication.c.

849{
850 if (relkind != RELKIND_RELATION && relkind != RELKIND_PARTITIONED_TABLE)
852 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
853 errmsg("cannot use relation \"%s.%s\" as logical replication target",
854 nspname, relname),
856}
int errdetail_relkind_not_supported(char relkind)
Definition: pg_class.c:24
NameData relname
Definition: pg_class.h:38

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 1152 of file execMain.c.

1154{
1155 Relation resultRel = resultRelInfo->ri_RelationDesc;
1156 FdwRoutine *fdwroutine;
1157
1158 /* Expect a fully-formed ResultRelInfo from InitResultRelInfo(). */
1159 Assert(resultRelInfo->ri_needLockTagTuple ==
1160 IsInplaceUpdateRelation(resultRel));
1161
1162 switch (resultRel->rd_rel->relkind)
1163 {
1164 case RELKIND_RELATION:
1165 case RELKIND_PARTITIONED_TABLE:
1166 CheckCmdReplicaIdentity(resultRel, operation);
1167 break;
1168 case RELKIND_SEQUENCE:
1169 ereport(ERROR,
1170 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1171 errmsg("cannot change sequence \"%s\"",
1172 RelationGetRelationName(resultRel))));
1173 break;
1174 case RELKIND_TOASTVALUE:
1175 ereport(ERROR,
1176 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1177 errmsg("cannot change TOAST relation \"%s\"",
1178 RelationGetRelationName(resultRel))));
1179 break;
1180 case RELKIND_VIEW:
1181
1182 /*
1183 * Okay only if there's a suitable INSTEAD OF trigger. Otherwise,
1184 * complain, but omit errdetail because we haven't got the
1185 * information handy (and given that it really shouldn't happen,
1186 * it's not worth great exertion to get).
1187 */
1188 if (!view_has_instead_trigger(resultRel, operation, mergeActions))
1189 error_view_not_updatable(resultRel, operation, mergeActions,
1190 NULL);
1191 break;
1192 case RELKIND_MATVIEW:
1194 ereport(ERROR,
1195 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1196 errmsg("cannot change materialized view \"%s\"",
1197 RelationGetRelationName(resultRel))));
1198 break;
1199 case RELKIND_FOREIGN_TABLE:
1200 /* Okay only if the FDW supports it */
1201 fdwroutine = resultRelInfo->ri_FdwRoutine;
1202 switch (operation)
1203 {
1204 case CMD_INSERT:
1205 if (fdwroutine->ExecForeignInsert == NULL)
1206 ereport(ERROR,
1207 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1208 errmsg("cannot insert into foreign table \"%s\"",
1209 RelationGetRelationName(resultRel))));
1210 if (fdwroutine->IsForeignRelUpdatable != NULL &&
1211 (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_INSERT)) == 0)
1212 ereport(ERROR,
1213 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1214 errmsg("foreign table \"%s\" does not allow inserts",
1215 RelationGetRelationName(resultRel))));
1216 break;
1217 case CMD_UPDATE:
1218 if (fdwroutine->ExecForeignUpdate == NULL)
1219 ereport(ERROR,
1220 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1221 errmsg("cannot update foreign table \"%s\"",
1222 RelationGetRelationName(resultRel))));
1223 if (fdwroutine->IsForeignRelUpdatable != NULL &&
1224 (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_UPDATE)) == 0)
1225 ereport(ERROR,
1226 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1227 errmsg("foreign table \"%s\" does not allow updates",
1228 RelationGetRelationName(resultRel))));
1229 break;
1230 case CMD_DELETE:
1231 if (fdwroutine->ExecForeignDelete == NULL)
1232 ereport(ERROR,
1233 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1234 errmsg("cannot delete from foreign table \"%s\"",
1235 RelationGetRelationName(resultRel))));
1236 if (fdwroutine->IsForeignRelUpdatable != NULL &&
1237 (fdwroutine->IsForeignRelUpdatable(resultRel) & (1 << CMD_DELETE)) == 0)
1238 ereport(ERROR,
1239 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
1240 errmsg("foreign table \"%s\" does not allow deletes",
1241 RelationGetRelationName(resultRel))));
1242 break;
1243 default:
1244 elog(ERROR, "unrecognized CmdType: %d", (int) operation);
1245 break;
1246 }
1247 break;
1248 default:
1249 ereport(ERROR,
1250 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1251 errmsg("cannot change relation \"%s\"",
1252 RelationGetRelationName(resultRel))));
1253 break;
1254 }
1255}
bool IsInplaceUpdateRelation(Relation relation)
Definition: catalog.c:152
#define elog(elevel,...)
Definition: elog.h:226
void CheckCmdReplicaIdentity(Relation rel, CmdType cmd)
bool MatViewIncrementalMaintenanceIsEnabled(void)
Definition: matview.c:964
@ CMD_INSERT
Definition: nodes.h:273
bool view_has_instead_trigger(Relation view, CmdType event, List *mergeActionList)
void error_view_not_updatable(Relation view, CmdType command, List *mergeActionList, const char *detail)
ExecForeignInsert_function ExecForeignInsert
Definition: fdwapi.h:232
ExecForeignUpdate_function ExecForeignUpdate
Definition: fdwapi.h:235
ExecForeignDelete_function ExecForeignDelete
Definition: fdwapi.h:236
IsForeignRelUpdatable_function IsForeignRelUpdatable
Definition: fdwapi.h:240
bool ri_needLockTagTuple
Definition: execnodes.h:507
Relation ri_RelationDesc
Definition: execnodes.h:475
struct FdwRoutine * ri_FdwRoutine
Definition: execnodes.h:528

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.

89{
90 EState *estate;
91 MemoryContext qcontext;
92 MemoryContext oldcontext;
93
94 /*
95 * Create the per-query context for this Executor run.
96 */
98 "ExecutorState",
100
101 /*
102 * Make the EState node within the per-query context. This way, we don't
103 * need a separate pfree() operation for it at shutdown.
104 */
105 oldcontext = MemoryContextSwitchTo(qcontext);
106
107 estate = makeNode(EState);
108
109 /*
110 * Initialize all fields of the Executor State structure
111 */
113 estate->es_snapshot = InvalidSnapshot; /* caller must initialize this */
114 estate->es_crosscheck_snapshot = InvalidSnapshot; /* no crosscheck */
115 estate->es_range_table = NIL;
116 estate->es_range_table_size = 0;
117 estate->es_relations = NULL;
118 estate->es_rowmarks = NULL;
119 estate->es_rteperminfos = NIL;
120 estate->es_plannedstmt = NULL;
121 estate->es_part_prune_infos = NIL;
122
123 estate->es_junkFilter = NULL;
124
125 estate->es_output_cid = (CommandId) 0;
126
127 estate->es_result_relations = NULL;
131
134
135 estate->es_param_list_info = NULL;
136 estate->es_param_exec_vals = NULL;
137
138 estate->es_queryEnv = NULL;
139
140 estate->es_query_cxt = qcontext;
141
142 estate->es_tupleTable = NIL;
143
144 estate->es_processed = 0;
145 estate->es_total_processed = 0;
146
147 estate->es_top_eflags = 0;
148 estate->es_instrument = 0;
149 estate->es_finished = false;
150 estate->es_aborted = false;
151
152 estate->es_exprcontexts = NIL;
153
154 estate->es_subplanstates = NIL;
155
156 estate->es_auxmodifytables = NIL;
157
158 estate->es_per_tuple_exprcontext = NULL;
159
160 estate->es_sourceText = NULL;
161
162 estate->es_use_parallel_mode = false;
165
166 estate->es_jit_flags = 0;
167 estate->es_jit = NULL;
168
169 /*
170 * Return the executor state structure
171 */
172 MemoryContextSwitchTo(oldcontext);
173
174 return estate;
175}
uint32 CommandId
Definition: c.h:637
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define makeNode(_type_)
Definition: nodes.h:161
#define NIL
Definition: pg_list.h:68
@ ForwardScanDirection
Definition: sdir.h:28
#define InvalidSnapshot
Definition: snapshot.h:119
uint64 es_processed
Definition: execnodes.h:712
bool es_aborted
Definition: execnodes.h:720
List * es_part_prune_infos
Definition: execnodes.h:668
struct ExecRowMark ** es_rowmarks
Definition: execnodes.h:663
int es_parallel_workers_to_launch
Definition: execnodes.h:745
List * es_tuple_routing_result_relations
Definition: execnodes.h:696
int es_top_eflags
Definition: execnodes.h:717
struct JitContext * es_jit
Definition: execnodes.h:763
int es_instrument
Definition: execnodes.h:718
PlannedStmt * es_plannedstmt
Definition: execnodes.h:666
QueryEnvironment * es_queryEnv
Definition: execnodes.h:705
ResultRelInfo ** es_result_relations
Definition: execnodes.h:683
ParamExecData * es_param_exec_vals
Definition: execnodes.h:703
uint64 es_total_processed
Definition: execnodes.h:714
List * es_range_table
Definition: execnodes.h:659
List * es_rteperminfos
Definition: execnodes.h:665
List * es_exprcontexts
Definition: execnodes.h:722
ParamListInfo es_param_list_info
Definition: execnodes.h:702
bool es_finished
Definition: execnodes.h:719
List * es_insert_pending_result_relations
Definition: execnodes.h:770
MemoryContext es_query_cxt
Definition: execnodes.h:708
List * es_tupleTable
Definition: execnodes.h:710
ScanDirection es_direction
Definition: execnodes.h:656
List * es_trig_target_relations
Definition: execnodes.h:699
int es_jit_flags
Definition: execnodes.h:762
List * es_opened_result_relations
Definition: execnodes.h:686
bool es_use_parallel_mode
Definition: execnodes.h:743
Relation * es_relations
Definition: execnodes.h:661
List * es_subplanstates
Definition: execnodes.h:724
ExprContext * es_per_tuple_exprcontext
Definition: execnodes.h:733
int es_parallel_workers_launched
Definition: execnodes.h:747
CommandId es_output_cid
Definition: execnodes.h:680
Index es_range_table_size
Definition: execnodes.h:660
List * es_insert_pending_modifytables
Definition: execnodes.h:771
const char * es_sourceText
Definition: execnodes.h:675
Snapshot es_snapshot
Definition: execnodes.h:657
List * es_auxmodifytables
Definition: execnodes.h:726
JunkFilter * es_junkFilter
Definition: execnodes.h:677
Snapshot es_crosscheck_snapshot
Definition: execnodes.h:658

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

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

◆ CreateExprContext()

ExprContext * CreateExprContext ( EState estate)

Definition at line 308 of file execUtils.c.

309{
311}
static ExprContext * CreateExprContextInternal(EState *estate, Size minContextSize, Size initBlockSize, Size maxBlockSize)
Definition: execUtils.c:238

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

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

◆ CreateStandaloneExprContext()

ExprContext * CreateStandaloneExprContext ( void  )

Definition at line 358 of file execUtils.c.

359{
360 ExprContext *econtext;
361
362 /* Create the ExprContext node within the caller's memory context */
363 econtext = makeNode(ExprContext);
364
365 /* Initialize fields of ExprContext */
366 econtext->ecxt_scantuple = NULL;
367 econtext->ecxt_innertuple = NULL;
368 econtext->ecxt_outertuple = NULL;
369
371
372 /*
373 * Create working memory for expression evaluation in this context.
374 */
375 econtext->ecxt_per_tuple_memory =
377 "ExprContext",
379
380 econtext->ecxt_param_exec_vals = NULL;
381 econtext->ecxt_param_list_info = NULL;
382
383 econtext->ecxt_aggvalues = NULL;
384 econtext->ecxt_aggnulls = NULL;
385
386 econtext->caseValue_datum = (Datum) 0;
387 econtext->caseValue_isNull = true;
388
389 econtext->domainValue_datum = (Datum) 0;
390 econtext->domainValue_isNull = true;
391
392 econtext->ecxt_estate = NULL;
393
394 econtext->ecxt_callbacks = NULL;
395
396 return econtext;
397}
uintptr_t Datum
Definition: postgres.h:69
Datum domainValue_datum
Definition: execnodes.h:299
ParamListInfo ecxt_param_list_info
Definition: execnodes.h:280
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:276
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:270
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:279
Datum * ecxt_aggvalues
Definition: execnodes.h:287
bool caseValue_isNull
Definition: execnodes.h:295
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:268
Datum caseValue_datum
Definition: execnodes.h:293
bool * ecxt_aggnulls
Definition: execnodes.h:289
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:275
ExprContext_CB * ecxt_callbacks
Definition: execnodes.h:313
bool domainValue_isNull
Definition: execnodes.h:301
struct EState * ecxt_estate
Definition: execnodes.h:310
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:272

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

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

◆ CreateWorkExprContext()

ExprContext * CreateWorkExprContext ( EState estate)

Definition at line 323 of file execUtils.c.

324{
325 Size maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
326
327 maxBlockSize = pg_prevpower2_size_t(work_mem * (Size) 1024 / 16);
328
329 /* But no bigger than ALLOCSET_DEFAULT_MAXSIZE */
330 maxBlockSize = Min(maxBlockSize, ALLOCSET_DEFAULT_MAXSIZE);
331
332 /* and no smaller than ALLOCSET_DEFAULT_INITSIZE */
333 maxBlockSize = Max(maxBlockSize, ALLOCSET_DEFAULT_INITSIZE);
334
336 ALLOCSET_DEFAULT_INITSIZE, maxBlockSize);
337}
#define Min(x, y)
Definition: c.h:975
#define Max(x, y)
Definition: c.h:969
int work_mem
Definition: globals.c:131
#define ALLOCSET_DEFAULT_MAXSIZE
Definition: memutils.h:159
#define ALLOCSET_DEFAULT_MINSIZE
Definition: memutils.h:157
#define ALLOCSET_DEFAULT_INITSIZE
Definition: memutils.h:158
#define pg_prevpower2_size_t
Definition: pg_bitutils.h:442

References ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE, ALLOCSET_DEFAULT_MINSIZE, CreateExprContextInternal(), Max, Min, pg_prevpower2_size_t, and work_mem.

Referenced by hash_create_memory().

◆ do_text_output_multiline()

void do_text_output_multiline ( TupOutputState tstate,
const char *  txt 
)

Definition at line 2492 of file execTuples.c.

2493{
2494 Datum values[1];
2495 bool isnull[1] = {false};
2496
2497 while (*txt)
2498 {
2499 const char *eol;
2500 int len;
2501
2502 eol = strchr(txt, '\n');
2503 if (eol)
2504 {
2505 len = eol - txt;
2506 eol++;
2507 }
2508 else
2509 {
2510 len = strlen(txt);
2511 eol = txt + len;
2512 }
2513
2515 do_tup_output(tstate, values, isnull);
2517 txt = eol;
2518 }
2519}
void do_tup_output(TupOutputState *tstate, const Datum *values, const bool *isnull)
Definition: execTuples.c:2464
void pfree(void *pointer)
Definition: mcxt.c:1524
const void size_t len
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:204

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

2465{
2466 TupleTableSlot *slot = tstate->slot;
2467 int natts = slot->tts_tupleDescriptor->natts;
2468
2469 /* make sure the slot is clear */
2470 ExecClearTuple(slot);
2471
2472 /* insert data */
2473 memcpy(slot->tts_values, values, natts * sizeof(Datum));
2474 memcpy(slot->tts_isnull, isnull, natts * sizeof(bool));
2475
2476 /* mark slot as containing a virtual tuple */
2478
2479 /* send the tuple to the receiver */
2480 (void) tstate->dest->receiveSlot(slot, tstate->dest);
2481
2482 /* clean up */
2483 ExecClearTuple(slot);
2484}
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition: execTuples.c:1741
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:123
bool * tts_isnull
Definition: tuptable.h:127
Datum * tts_values
Definition: tuptable.h:125
bool(* receiveSlot)(TupleTableSlot *slot, DestReceiver *self)
Definition: dest.h:118
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:458

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

2523{
2524 tstate->dest->rShutdown(tstate->dest);
2525 /* note that destroying the dest is not ours to do */
2527 pfree(tstate);
2528}
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1443
void(* rShutdown)(DestReceiver *self)
Definition: dest.h:124

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 2725 of file execMain.c.

2727{
2728 TupleTableSlot *slot;
2729 TupleTableSlot *testslot;
2730
2731 Assert(rti > 0);
2732
2733 /*
2734 * Need to run a recheck subquery. Initialize or reinitialize EPQ state.
2735 */
2736 EvalPlanQualBegin(epqstate);
2737
2738 /*
2739 * Callers will often use the EvalPlanQualSlot to store the tuple to avoid
2740 * an unnecessary copy.
2741 */
2742 testslot = EvalPlanQualSlot(epqstate, relation, rti);
2743 if (testslot != inputslot)
2744 ExecCopySlot(testslot, inputslot);
2745
2746 /*
2747 * Mark that an EPQ tuple is available for this relation. (If there is
2748 * more than one result relation, the others remain marked as having no
2749 * tuple available.)
2750 */
2751 epqstate->relsubs_done[rti - 1] = false;
2752 epqstate->relsubs_blocked[rti - 1] = false;
2753
2754 /*
2755 * Run the EPQ query. We assume it will return at most one tuple.
2756 */
2757 slot = EvalPlanQualNext(epqstate);
2758
2759 /*
2760 * If we got a tuple, force the slot to materialize the tuple so that it
2761 * is not dependent on any local state in the EPQ query (in particular,
2762 * it's highly likely that the slot contains references to any pass-by-ref
2763 * datums that may be present in copyTuple). As with the next step, this
2764 * is to guard against early re-use of the EPQ query.
2765 */
2766 if (!TupIsNull(slot))
2767 ExecMaterializeSlot(slot);
2768
2769 /*
2770 * Clear out the test tuple, and mark that no tuple is available here.
2771 * This is needed in case the EPQ state is re-used to test a tuple for a
2772 * different target relation.
2773 */
2774 ExecClearTuple(testslot);
2775 epqstate->relsubs_blocked[rti - 1] = true;
2776
2777 return slot;
2778}
TupleTableSlot * EvalPlanQualSlot(EPQState *epqstate, Relation relation, Index rti)
Definition: execMain.c:2853
void EvalPlanQualBegin(EPQState *epqstate)
Definition: execMain.c:3008
TupleTableSlot * EvalPlanQualNext(EPQState *epqstate)
Definition: execMain.c:2992
bool * relsubs_blocked
Definition: execnodes.h:1350
bool * relsubs_done
Definition: execnodes.h:1341
#define TupIsNull(slot)
Definition: tuptable.h:310
static TupleTableSlot * ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition: tuptable.h:525
static void ExecMaterializeSlot(TupleTableSlot *slot)
Definition: tuptable.h:476

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 3008 of file execMain.c.

3009{
3010 EState *parentestate = epqstate->parentestate;
3011 EState *recheckestate = epqstate->recheckestate;
3012
3013 if (recheckestate == NULL)
3014 {
3015 /* First time through, so create a child EState */
3016 EvalPlanQualStart(epqstate, epqstate->plan);
3017 }
3018 else
3019 {
3020 /*
3021 * We already have a suitable child EPQ tree, so just reset it.
3022 */
3023 Index rtsize = parentestate->es_range_table_size;
3024 PlanState *rcplanstate = epqstate->recheckplanstate;
3025
3026 /*
3027 * Reset the relsubs_done[] flags to equal relsubs_blocked[], so that
3028 * the EPQ run will never attempt to fetch tuples from blocked target
3029 * relations.
3030 */
3031 memcpy(epqstate->relsubs_done, epqstate->relsubs_blocked,
3032 rtsize * sizeof(bool));
3033
3034 /* Recopy current values of parent parameters */
3035 if (parentestate->es_plannedstmt->paramExecTypes != NIL)
3036 {
3037 int i;
3038
3039 /*
3040 * Force evaluation of any InitPlan outputs that could be needed
3041 * by the subplan, just in case they got reset since
3042 * EvalPlanQualStart (see comments therein).
3043 */
3044 ExecSetParamPlanMulti(rcplanstate->plan->extParam,
3045 GetPerTupleExprContext(parentestate));
3046
3047 i = list_length(parentestate->es_plannedstmt->paramExecTypes);
3048
3049 while (--i >= 0)
3050 {
3051 /* copy value if any, but not execPlan link */
3052 recheckestate->es_param_exec_vals[i].value =
3053 parentestate->es_param_exec_vals[i].value;
3054 recheckestate->es_param_exec_vals[i].isnull =
3055 parentestate->es_param_exec_vals[i].isnull;
3056 }
3057 }
3058
3059 /*
3060 * Mark child plan tree as needing rescan at all scan nodes. The
3061 * first ExecProcNode will take care of actually doing the rescan.
3062 */
3063 rcplanstate->chgParam = bms_add_member(rcplanstate->chgParam,
3064 epqstate->epqParam);
3065 }
3066}
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
unsigned int Index
Definition: c.h:585
static void EvalPlanQualStart(EPQState *epqstate, Plan *planTree)
Definition: execMain.c:3075
#define GetPerTupleExprContext(estate)
Definition: executor.h:678
int i
Definition: isn.c:77
void ExecSetParamPlanMulti(const Bitmapset *params, ExprContext *econtext)
Definition: nodeSubplan.c:1276
static int list_length(const List *l)
Definition: pg_list.h:152
Plan * plan
Definition: execnodes.h:1313
int epqParam
Definition: execnodes.h:1296
EState * parentestate
Definition: execnodes.h:1295
EState * recheckestate
Definition: execnodes.h:1327
PlanState * recheckplanstate
Definition: execnodes.h:1352
bool isnull
Definition: params.h:150
Datum value
Definition: params.h:149
Plan * plan
Definition: execnodes.h:1159
Bitmapset * chgParam
Definition: execnodes.h:1191
Bitmapset * extParam
Definition: plannodes.h:229
List * paramExecTypes
Definition: plannodes.h:136

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 3249 of file execMain.c.

3250{
3251 EState *estate = epqstate->recheckestate;
3252 Index rtsize;
3253 MemoryContext oldcontext;
3254 ListCell *l;
3255
3256 rtsize = epqstate->parentestate->es_range_table_size;
3257
3258 /*
3259 * We may have a tuple table, even if EPQ wasn't started, because we allow
3260 * use of EvalPlanQualSlot() without calling EvalPlanQualBegin().
3261 */
3262 if (epqstate->tuple_table != NIL)
3263 {
3264 memset(epqstate->relsubs_slot, 0,
3265 rtsize * sizeof(TupleTableSlot *));
3266 ExecResetTupleTable(epqstate->tuple_table, true);
3267 epqstate->tuple_table = NIL;
3268 }
3269
3270 /* EPQ wasn't started, nothing further to do */
3271 if (estate == NULL)
3272 return;
3273
3274 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
3275
3276 ExecEndNode(epqstate->recheckplanstate);
3277
3278 foreach(l, estate->es_subplanstates)
3279 {
3280 PlanState *subplanstate = (PlanState *) lfirst(l);
3281
3282 ExecEndNode(subplanstate);
3283 }
3284
3285 /* throw away the per-estate tuple table, some node may have used it */
3286 ExecResetTupleTable(estate->es_tupleTable, false);
3287
3288 /* Close any result and trigger target relations attached to this EState */
3290
3291 MemoryContextSwitchTo(oldcontext);
3292
3293 FreeExecutorState(estate);
3294
3295 /* Mark EPQState idle */
3296 epqstate->origslot = NULL;
3297 epqstate->recheckestate = NULL;
3298 epqstate->recheckplanstate = NULL;
3299 epqstate->relsubs_rowmark = NULL;
3300 epqstate->relsubs_done = NULL;
3301 epqstate->relsubs_blocked = NULL;
3302}
void ExecCloseResultRelations(EState *estate)
Definition: execMain.c:1651
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:562
void ExecResetTupleTable(List *tupleTable, bool shouldFree)
Definition: execTuples.c:1380
void FreeExecutorState(EState *estate)
Definition: execUtils.c:193
#define lfirst(lc)
Definition: pg_list.h:172
ExecAuxRowMark ** relsubs_rowmark
Definition: execnodes.h:1334
TupleTableSlot * origslot
Definition: execnodes.h:1322
TupleTableSlot ** relsubs_slot
Definition: execnodes.h:1306
List * tuple_table
Definition: execnodes.h:1305

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 2881 of file execMain.c.

2882{
2883 ExecAuxRowMark *earm = epqstate->relsubs_rowmark[rti - 1];
2884 ExecRowMark *erm;
2885 Datum datum;
2886 bool isNull;
2887
2888 Assert(earm != NULL);
2889 Assert(epqstate->origslot != NULL);
2890
2891 erm = earm->rowmark;
2892
2894 elog(ERROR, "EvalPlanQual doesn't support locking rowmarks");
2895
2896 /* if child rel, must check whether it produced this row */
2897 if (erm->rti != erm->prti)
2898 {
2899 Oid tableoid;
2900
2901 datum = ExecGetJunkAttribute(epqstate->origslot,
2902 earm->toidAttNo,
2903 &isNull);
2904 /* non-locked rels could be on the inside of outer joins */
2905 if (isNull)
2906 return false;
2907
2908 tableoid = DatumGetObjectId(datum);
2909
2910 Assert(OidIsValid(erm->relid));
2911 if (tableoid != erm->relid)
2912 {
2913 /* this child is inactive right now */
2914 return false;
2915 }
2916 }
2917
2918 if (erm->markType == ROW_MARK_REFERENCE)
2919 {
2920 Assert(erm->relation != NULL);
2921
2922 /* fetch the tuple's ctid */
2923 datum = ExecGetJunkAttribute(epqstate->origslot,
2924 earm->ctidAttNo,
2925 &isNull);
2926 /* non-locked rels could be on the inside of outer joins */
2927 if (isNull)
2928 return false;
2929
2930 /* fetch requests on foreign tables must be passed to their FDW */
2931 if (erm->relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
2932 {
2933 FdwRoutine *fdwroutine;
2934 bool updated = false;
2935
2936 fdwroutine = GetFdwRoutineForRelation(erm->relation, false);
2937 /* this should have been checked already, but let's be safe */
2938 if (fdwroutine->RefetchForeignRow == NULL)
2939 ereport(ERROR,
2940 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2941 errmsg("cannot lock rows in foreign table \"%s\"",
2943
2944 fdwroutine->RefetchForeignRow(epqstate->recheckestate,
2945 erm,
2946 datum,
2947 slot,
2948 &updated);
2949 if (TupIsNull(slot))
2950 elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
2951
2952 /*
2953 * Ideally we'd insist on updated == false here, but that assumes
2954 * that FDWs can track that exactly, which they might not be able
2955 * to. So just ignore the flag.
2956 */
2957 return true;
2958 }
2959 else
2960 {
2961 /* ordinary table, fetch the tuple */
2964 SnapshotAny, slot))
2965 elog(ERROR, "failed to fetch tuple for EvalPlanQual recheck");
2966 return true;
2967 }
2968 }
2969 else
2970 {
2971 Assert(erm->markType == ROW_MARK_COPY);
2972
2973 /* fetch the whole-row Var for the relation */
2974 datum = ExecGetJunkAttribute(epqstate->origslot,
2975 earm->wholeAttNo,
2976 &isNull);
2977 /* non-locked rels could be on the inside of outer joins */
2978 if (isNull)
2979 return false;
2980
2981 ExecStoreHeapTupleDatum(datum, slot);
2982 return true;
2983 }
2984}
void ExecStoreHeapTupleDatum(Datum data, TupleTableSlot *slot)
Definition: execTuples.c:1795
static Datum ExecGetJunkAttribute(TupleTableSlot *slot, AttrNumber attno, bool *isNull)
Definition: executor.h:222
FdwRoutine * GetFdwRoutineForRelation(Relation relation, bool makecopy)
Definition: foreign.c:442
#define RowMarkRequiresRowShareLock(marktype)
Definition: plannodes.h:1494
@ ROW_MARK_COPY
Definition: plannodes.h:1491
@ ROW_MARK_REFERENCE
Definition: plannodes.h:1490
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:247
unsigned int Oid
Definition: postgres_ext.h:30
#define SnapshotAny
Definition: snapmgr.h:33
AttrNumber wholeAttNo
Definition: execnodes.h:823
ExecRowMark * rowmark
Definition: execnodes.h:820
AttrNumber toidAttNo
Definition: execnodes.h:822
AttrNumber ctidAttNo
Definition: execnodes.h:821
Index rti
Definition: execnodes.h:798
Index prti
Definition: execnodes.h:799
Relation relation
Definition: execnodes.h:796
RowMarkType markType
Definition: execnodes.h:801
RefetchForeignRow_function RefetchForeignRow
Definition: fdwapi.h:248
static bool table_tuple_fetch_row_version(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot)
Definition: tableam.h:1248

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 2794 of file execMain.c.

2797{
2798 Index rtsize = parentestate->es_range_table_size;
2799
2800 /* initialize data not changing over EPQState's lifetime */
2801 epqstate->parentestate = parentestate;
2802 epqstate->epqParam = epqParam;
2803 epqstate->resultRelations = resultRelations;
2804
2805 /*
2806 * Allocate space to reference a slot for each potential rti - do so now
2807 * rather than in EvalPlanQualBegin(), as done for other dynamically
2808 * allocated resources, so EvalPlanQualSlot() can be used to hold tuples
2809 * that *may* need EPQ later, without forcing the overhead of
2810 * EvalPlanQualBegin().
2811 */
2812 epqstate->tuple_table = NIL;
2813 epqstate->relsubs_slot = (TupleTableSlot **)
2814 palloc0(rtsize * sizeof(TupleTableSlot *));
2815
2816 /* ... and remember data that EvalPlanQualBegin will need */
2817 epqstate->plan = subplan;
2818 epqstate->arowMarks = auxrowmarks;
2819
2820 /* ... and mark the EPQ state inactive */
2821 epqstate->origslot = NULL;
2822 epqstate->recheckestate = NULL;
2823 epqstate->recheckplanstate = NULL;
2824 epqstate->relsubs_rowmark = NULL;
2825 epqstate->relsubs_done = NULL;
2826 epqstate->relsubs_blocked = NULL;
2827}
void * palloc0(Size size)
Definition: mcxt.c:1347
List * resultRelations
Definition: execnodes.h:1297
List * arowMarks
Definition: execnodes.h:1314

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 2992 of file execMain.c.

2993{
2994 MemoryContext oldcontext;
2995 TupleTableSlot *slot;
2996
2997 oldcontext = MemoryContextSwitchTo(epqstate->recheckestate->es_query_cxt);
2998 slot = ExecProcNode(epqstate->recheckplanstate);
2999 MemoryContextSwitchTo(oldcontext);
3000
3001 return slot;
3002}
static TupleTableSlot * ExecProcNode(PlanState *node)
Definition: executor.h:336

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 2836 of file execMain.c.

2837{
2838 /* If we have a live EPQ query, shut it down */
2839 EvalPlanQualEnd(epqstate);
2840 /* And set/change the plan pointer */
2841 epqstate->plan = subplan;
2842 /* The rowmarks depend on the plan, too */
2843 epqstate->arowMarks = auxrowmarks;
2844}
void EvalPlanQualEnd(EPQState *epqstate)
Definition: execMain.c:3249

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

Referenced by ExecInitModifyTable().

◆ EvalPlanQualSlot()

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

Definition at line 2853 of file execMain.c.

2855{
2856 TupleTableSlot **slot;
2857
2858 Assert(relation);
2859 Assert(rti > 0 && rti <= epqstate->parentestate->es_range_table_size);
2860 slot = &epqstate->relsubs_slot[rti - 1];
2861
2862 if (*slot == NULL)
2863 {
2864 MemoryContext oldcontext;
2865
2866 oldcontext = MemoryContextSwitchTo(epqstate->parentestate->es_query_cxt);
2867 *slot = table_slot_create(relation, &epqstate->tuple_table);
2868 MemoryContextSwitchTo(oldcontext);
2869 }
2870
2871 return *slot;
2872}
TupleTableSlot * table_slot_create(Relation relation, List **reglist)
Definition: tableam.c:92

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

◆ ExecAssignExprContext()

◆ ExecAssignProjectionInfo()

void ExecAssignProjectionInfo ( PlanState planstate,
TupleDesc  inputDesc 
)

Definition at line 584 of file execUtils.c.

586{
587 planstate->ps_ProjInfo =
589 planstate->ps_ExprContext,
590 planstate->ps_ResultTupleSlot,
591 planstate,
592 inputDesc);
593}
ProjectionInfo * ExecBuildProjectionInfo(List *targetList, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent, TupleDesc inputDesc)
Definition: execExpr.c:370
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:1197
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1199
List * targetlist
Definition: plannodes.h:209

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

◆ ExecAssignScanProjectionInfoWithVarno()

void ExecAssignScanProjectionInfoWithVarno ( ScanState node,
int  varno 
)

◆ ExecAssignScanType()

void ExecAssignScanType ( ScanState scanstate,
TupleDesc  tupDesc 
)

Definition at line 693 of file execUtils.c.

694{
695 TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
696
697 ExecSetSlotDescriptor(slot, tupDesc);
698}
void ExecSetSlotDescriptor(TupleTableSlot *slot, TupleDesc tupdesc)
Definition: execTuples.c:1478

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 2655 of file execMain.c.

2656{
2658 char resname[32];
2659
2660 aerm->rowmark = erm;
2661
2662 /* Look up the resjunk columns associated with this rowmark */
2663 if (erm->markType != ROW_MARK_COPY)
2664 {
2665 /* need ctid for all methods other than COPY */
2666 snprintf(resname, sizeof(resname), "ctid%u", erm->rowmarkId);
2667 aerm->ctidAttNo = ExecFindJunkAttributeInTlist(targetlist,
2668 resname);
2670 elog(ERROR, "could not find junk %s column", resname);
2671 }
2672 else
2673 {
2674 /* need wholerow if COPY */
2675 snprintf(resname, sizeof(resname), "wholerow%u", erm->rowmarkId);
2676 aerm->wholeAttNo = ExecFindJunkAttributeInTlist(targetlist,
2677 resname);
2679 elog(ERROR, "could not find junk %s column", resname);
2680 }
2681
2682 /* if child rel, need tableoid */
2683 if (erm->rti != erm->prti)
2684 {
2685 snprintf(resname, sizeof(resname), "tableoid%u", erm->rowmarkId);
2686 aerm->toidAttNo = ExecFindJunkAttributeInTlist(targetlist,
2687 resname);
2689 elog(ERROR, "could not find junk %s column", resname);
2690 }
2691
2692 return aerm;
2693}
#define AttributeNumberIsValid(attributeNumber)
Definition: attnum.h:34
AttrNumber ExecFindJunkAttributeInTlist(List *targetlist, const char *attrName)
Definition: execJunk.c:222
#define snprintf
Definition: port.h:239
Index rowmarkId
Definition: execnodes.h:800

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

Referenced by ExecInitLockRows(), and ExecInitModifyTable().

◆ ExecBuildGroupingEqual()

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

Definition at line 4465 of file execExpr.c.

4472{
4474 ExprEvalStep scratch = {0};
4475 int maxatt = -1;
4476 List *adjust_jumps = NIL;
4477 ListCell *lc;
4478
4479 /*
4480 * When no columns are actually compared, the result's always true. See
4481 * special case in ExecQual().
4482 */
4483 if (numCols == 0)
4484 return NULL;
4485
4486 state->expr = NULL;
4487 state->flags = EEO_FLAG_IS_QUAL;
4488 state->parent = parent;
4489
4490 scratch.resvalue = &state->resvalue;
4491 scratch.resnull = &state->resnull;
4492
4493 /* compute max needed attribute */
4494 for (int natt = 0; natt < numCols; natt++)
4495 {
4496 int attno = keyColIdx[natt];
4497
4498 if (attno > maxatt)
4499 maxatt = attno;
4500 }
4501 Assert(maxatt >= 0);
4502
4503 /* push deform steps */
4504 scratch.opcode = EEOP_INNER_FETCHSOME;
4505 scratch.d.fetch.last_var = maxatt;
4506 scratch.d.fetch.fixed = false;
4507 scratch.d.fetch.known_desc = ldesc;
4508 scratch.d.fetch.kind = lops;
4509 if (ExecComputeSlotInfo(state, &scratch))
4510 ExprEvalPushStep(state, &scratch);
4511
4512 scratch.opcode = EEOP_OUTER_FETCHSOME;
4513 scratch.d.fetch.last_var = maxatt;
4514 scratch.d.fetch.fixed = false;
4515 scratch.d.fetch.known_desc = rdesc;
4516 scratch.d.fetch.kind = rops;
4517 if (ExecComputeSlotInfo(state, &scratch))
4518 ExprEvalPushStep(state, &scratch);
4519
4520 /*
4521 * Start comparing at the last field (least significant sort key). That's
4522 * the most likely to be different if we are dealing with sorted input.
4523 */
4524 for (int natt = numCols; --natt >= 0;)
4525 {
4526 int attno = keyColIdx[natt];
4527 Form_pg_attribute latt = TupleDescAttr(ldesc, attno - 1);
4528 Form_pg_attribute ratt = TupleDescAttr(rdesc, attno - 1);
4529 Oid foid = eqfunctions[natt];
4530 Oid collid = collations[natt];
4531 FmgrInfo *finfo;
4532 FunctionCallInfo fcinfo;
4533 AclResult aclresult;
4534
4535 /* Check permission to call function */
4536 aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
4537 if (aclresult != ACLCHECK_OK)
4538 aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
4539
4541
4542 /* Set up the primary fmgr lookup information */
4543 finfo = palloc0(sizeof(FmgrInfo));
4544 fcinfo = palloc0(SizeForFunctionCallInfo(2));
4545 fmgr_info(foid, finfo);
4546 fmgr_info_set_expr(NULL, finfo);
4547 InitFunctionCallInfoData(*fcinfo, finfo, 2,
4548 collid, NULL, NULL);
4549
4550 /* left arg */
4551 scratch.opcode = EEOP_INNER_VAR;
4552 scratch.d.var.attnum = attno - 1;
4553 scratch.d.var.vartype = latt->atttypid;
4555 scratch.resvalue = &fcinfo->args[0].value;
4556 scratch.resnull = &fcinfo->args[0].isnull;
4557 ExprEvalPushStep(state, &scratch);
4558
4559 /* right arg */
4560 scratch.opcode = EEOP_OUTER_VAR;
4561 scratch.d.var.attnum = attno - 1;
4562 scratch.d.var.vartype = ratt->atttypid;
4564 scratch.resvalue = &fcinfo->args[1].value;
4565 scratch.resnull = &fcinfo->args[1].isnull;
4566 ExprEvalPushStep(state, &scratch);
4567
4568 /* evaluate distinctness */
4569 scratch.opcode = EEOP_NOT_DISTINCT;
4570 scratch.d.func.finfo = finfo;
4571 scratch.d.func.fcinfo_data = fcinfo;
4572 scratch.d.func.fn_addr = finfo->fn_addr;
4573 scratch.d.func.nargs = 2;
4574 scratch.resvalue = &state->resvalue;
4575 scratch.resnull = &state->resnull;
4576 ExprEvalPushStep(state, &scratch);
4577
4578 /* then emit EEOP_QUAL to detect if result is false (or null) */
4579 scratch.opcode = EEOP_QUAL;
4580 scratch.d.qualexpr.jumpdone = -1;
4581 scratch.resvalue = &state->resvalue;
4582 scratch.resnull = &state->resnull;
4583 ExprEvalPushStep(state, &scratch);
4584 adjust_jumps = lappend_int(adjust_jumps,
4585 state->steps_len - 1);
4586 }
4587
4588 /* adjust jump targets */
4589 foreach(lc, adjust_jumps)
4590 {
4591 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4592
4593 Assert(as->opcode == EEOP_QUAL);
4594 Assert(as->d.qualexpr.jumpdone == -1);
4595 as->d.qualexpr.jumpdone = state->steps_len;
4596 }
4597
4598 scratch.resvalue = NULL;
4599 scratch.resnull = NULL;
4600 scratch.opcode = EEOP_DONE_RETURN;
4601 ExprEvalPushStep(state, &scratch);
4602
4604
4605 return state;
4606}
AclResult
Definition: acl.h:182
@ ACLCHECK_OK
Definition: acl.h:183
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition: aclchk.c:2639
AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode)
Definition: aclchk.c:3821
Oid collid
void ExprEvalPushStep(ExprState *es, const ExprEvalStep *s)
Definition: execExpr.c:2678
static bool ExecComputeSlotInfo(ExprState *state, ExprEvalStep *op)
Definition: execExpr.c:3062
static void ExecReadyExpr(ExprState *state)
Definition: execExpr.c:902
@ EEOP_NOT_DISTINCT
Definition: execExpr.h:190
@ EEOP_DONE_RETURN
Definition: execExpr.h:69
@ EEOP_INNER_VAR
Definition: execExpr.h:82
@ EEOP_QUAL
Definition: execExpr.h:148
@ EEOP_INNER_FETCHSOME
Definition: execExpr.h:75
@ EEOP_OUTER_FETCHSOME
Definition: execExpr.h:76
@ EEOP_OUTER_VAR
Definition: execExpr.h:83
#define EEO_FLAG_IS_QUAL
Definition: execnodes.h:77
void fmgr_info(Oid functionId, FmgrInfo *finfo)
Definition: fmgr.c:127
#define SizeForFunctionCallInfo(nargs)
Definition: fmgr.h:102
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150
#define fmgr_info_set_expr(expr, finfo)
Definition: fmgr.h:135
List * lappend_int(List *list, int datum)
Definition: list.c:357
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1748
Oid GetUserId(void)
Definition: miscinit.c:520
#define InvokeFunctionExecuteHook(objectId)
Definition: objectaccess.h:213
@ OBJECT_FUNCTION
Definition: parsenodes.h:2336
#define ACL_EXECUTE
Definition: parsenodes.h:83
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:202
#define lfirst_int(lc)
Definition: pg_list.h:173
@ VAR_RETURNING_DEFAULT
Definition: primnodes.h:256
int last_var
Definition: execExpr.h:325
struct ExprEvalStep::@55::@57 var
VarReturningType varreturningtype
Definition: execExpr.h:341
intptr_t opcode
Definition: execExpr.h:307
PGFunction fn_addr
Definition: execExpr.h:391
TupleDesc known_desc
Definition: execExpr.h:329
Datum * resvalue
Definition: execExpr.h:310
const TupleTableSlotOps * kind
Definition: execExpr.h:331
FunctionCallInfo fcinfo_data
Definition: execExpr.h:389
int jumpdone
Definition: execExpr.h:374
union ExprEvalStep::@55 d
bool fixed
Definition: execExpr.h:327
struct ExprEvalStep::@55::@65 qualexpr
bool * resnull
Definition: execExpr.h:311
struct ExprEvalStep::@55::@63 func
FmgrInfo * finfo
Definition: execExpr.h:388
struct ExprEvalStep::@55::@56 fetch
Definition: fmgr.h:57
PGFunction fn_addr
Definition: fmgr.h:58
NullableDatum args[FLEXIBLE_ARRAY_MEMBER]
Definition: fmgr.h:95
Definition: pg_list.h:54
Datum value
Definition: postgres.h:80
bool isnull
Definition: postgres.h:82
Definition: regguts.h:323
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160

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

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

◆ ExecBuildHash32Expr()

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

Definition at line 4300 of file execExpr.c.

4304{
4306 ExprEvalStep scratch = {0};
4307 NullableDatum *iresult = NULL;
4308 List *adjust_jumps = NIL;
4309 ListCell *lc;
4310 ListCell *lc2;
4311 intptr_t strict_opcode;
4312 intptr_t opcode;
4313 int num_exprs = list_length(hash_exprs);
4314
4315 Assert(num_exprs == list_length(collations));
4316
4317 state->parent = parent;
4318
4319 /* Insert setup steps as needed. */
4320 ExecCreateExprSetupSteps(state, (Node *) hash_exprs);
4321
4322 /*
4323 * Make a place to store intermediate hash values between subsequent
4324 * hashing of individual expressions. We only need this if there is more
4325 * than one expression to hash or an initial value plus one expression.
4326 */
4327 if ((int64) num_exprs + (init_value != 0) > 1)
4328 iresult = palloc(sizeof(NullableDatum));
4329
4330 if (init_value == 0)
4331 {
4332 /*
4333 * No initial value, so we can assign the result of the hash function
4334 * for the first hash_expr without having to concern ourselves with
4335 * combining the result with any initial value.
4336 */
4337 strict_opcode = EEOP_HASHDATUM_FIRST_STRICT;
4338 opcode = EEOP_HASHDATUM_FIRST;
4339 }
4340 else
4341 {
4342 /*
4343 * Set up operation to set the initial value. Normally we store this
4344 * in the intermediate hash value location, but if there are no exprs
4345 * to hash, store it in the ExprState's result field.
4346 */
4348 scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
4349 scratch.resvalue = num_exprs > 0 ? &iresult->value : &state->resvalue;
4350 scratch.resnull = num_exprs > 0 ? &iresult->isnull : &state->resnull;
4351
4352 ExprEvalPushStep(state, &scratch);
4353
4354 /*
4355 * When using an initial value use the NEXT32/NEXT32_STRICT ops as the
4356 * FIRST/FIRST_STRICT ops would overwrite the stored initial value.
4357 */
4358 strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
4359 opcode = EEOP_HASHDATUM_NEXT32;
4360 }
4361
4362 forboth(lc, hash_exprs, lc2, collations)
4363 {
4364 Expr *expr = (Expr *) lfirst(lc);
4365 FmgrInfo *finfo;
4366 FunctionCallInfo fcinfo;
4367 int i = foreach_current_index(lc);
4368 Oid funcid;
4369 Oid inputcollid = lfirst_oid(lc2);
4370
4371 funcid = hashfunc_oids[i];
4372
4373 /* Allocate hash function lookup data. */
4374 finfo = palloc0(sizeof(FmgrInfo));
4375 fcinfo = palloc0(SizeForFunctionCallInfo(1));
4376
4377 fmgr_info(funcid, finfo);
4378
4379 /*
4380 * Build the steps to evaluate the hash function's argument have it so
4381 * the value of that is stored in the 0th argument of the hash func.
4382 */
4383 ExecInitExprRec(expr,
4384 state,
4385 &fcinfo->args[0].value,
4386 &fcinfo->args[0].isnull);
4387
4388 if (i == num_exprs - 1)
4389 {
4390 /* the result for hashing the final expr is stored in the state */
4391 scratch.resvalue = &state->resvalue;
4392 scratch.resnull = &state->resnull;
4393 }
4394 else
4395 {
4396 Assert(iresult != NULL);
4397
4398 /* intermediate values are stored in an intermediate result */
4399 scratch.resvalue = &iresult->value;
4400 scratch.resnull = &iresult->isnull;
4401 }
4402
4403 /*
4404 * NEXT32 opcodes need to look at the intermediate result. We might
4405 * as well just set this for all ops. FIRSTs won't look at it.
4406 */
4407 scratch.d.hashdatum.iresult = iresult;
4408
4409 /* Initialize function call parameter structure too */
4410 InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);
4411
4412 scratch.d.hashdatum.finfo = finfo;
4413 scratch.d.hashdatum.fcinfo_data = fcinfo;
4414 scratch.d.hashdatum.fn_addr = finfo->fn_addr;
4415
4416 scratch.opcode = opstrict[i] && !keep_nulls ? strict_opcode : opcode;
4417 scratch.d.hashdatum.jumpdone = -1;
4418
4419 ExprEvalPushStep(state, &scratch);
4420 adjust_jumps = lappend_int(adjust_jumps, state->steps_len - 1);
4421
4422 /*
4423 * For subsequent keys we must combine the hash value with the
4424 * previous hashes.
4425 */
4426 strict_opcode = EEOP_HASHDATUM_NEXT32_STRICT;
4427 opcode = EEOP_HASHDATUM_NEXT32;
4428 }
4429
4430 /* adjust jump targets */
4431 foreach(lc, adjust_jumps)
4432 {
4433 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4434
4439 Assert(as->d.hashdatum.jumpdone == -1);
4440 as->d.hashdatum.jumpdone = state->steps_len;
4441 }
4442
4443 scratch.resvalue = NULL;
4444 scratch.resnull = NULL;
4445 scratch.opcode = EEOP_DONE_RETURN;
4446 ExprEvalPushStep(state, &scratch);
4447
4449
4450 return state;
4451}
int64_t int64
Definition: c.h:499
static void ExecInitExprRec(Expr *node, ExprState *state, Datum *resv, bool *resnull)
Definition: execExpr.c:919
static void ExecCreateExprSetupSteps(ExprState *state, Node *node)
Definition: execExpr.c:2881
@ EEOP_HASHDATUM_NEXT32_STRICT
Definition: execExpr.h:259
@ EEOP_HASHDATUM_FIRST_STRICT
Definition: execExpr.h:257
@ EEOP_HASHDATUM_NEXT32
Definition: execExpr.h:258
@ EEOP_HASHDATUM_FIRST
Definition: execExpr.h:256
@ EEOP_HASHDATUM_SET_INITVAL
Definition: execExpr.h:255
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
#define foreach_current_index(var_or_cell)
Definition: pg_list.h:403
#define lfirst_oid(lc)
Definition: pg_list.h:174
static Datum UInt32GetDatum(uint32 X)
Definition: postgres.h:237
NullableDatum * iresult
Definition: execExpr.h:610
struct ExprEvalStep::@55::@86 hashdatum_initvalue
struct ExprEvalStep::@55::@87 hashdatum
Datum init_value
Definition: execExpr.h:598
Definition: nodes.h:135

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

Referenced by ExecInitHashJoin().

◆ ExecBuildHash32FromAttrs()

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

Definition at line 4141 of file execExpr.c.

4145{
4147 ExprEvalStep scratch = {0};
4148 NullableDatum *iresult = NULL;
4149 intptr_t opcode;
4150 AttrNumber last_attnum = 0;
4151
4152 Assert(numCols >= 0);
4153
4154 state->parent = parent;
4155
4156 /*
4157 * Make a place to store intermediate hash values between subsequent
4158 * hashing of individual columns. We only need this if there is more than
4159 * one column to hash or an initial value plus one column.
4160 */
4161 if ((int64) numCols + (init_value != 0) > 1)
4162 iresult = palloc(sizeof(NullableDatum));
4163
4164 /* find the highest attnum so we deform the tuple to that point */
4165 for (int i = 0; i < numCols; i++)
4166 last_attnum = Max(last_attnum, keyColIdx[i]);
4167
4168 scratch.opcode = EEOP_INNER_FETCHSOME;
4169 scratch.d.fetch.last_var = last_attnum;
4170 scratch.d.fetch.fixed = false;
4171 scratch.d.fetch.kind = ops;
4172 scratch.d.fetch.known_desc = desc;
4173 if (ExecComputeSlotInfo(state, &scratch))
4174 ExprEvalPushStep(state, &scratch);
4175
4176 if (init_value == 0)
4177 {
4178 /*
4179 * No initial value, so we can assign the result of the hash function
4180 * for the first attribute without having to concern ourselves with
4181 * combining the result with any initial value.
4182 */
4183 opcode = EEOP_HASHDATUM_FIRST;
4184 }
4185 else
4186 {
4187 /*
4188 * Set up operation to set the initial value. Normally we store this
4189 * in the intermediate hash value location, but if there are no
4190 * columns to hash, store it in the ExprState's result field.
4191 */
4193 scratch.d.hashdatum_initvalue.init_value = UInt32GetDatum(init_value);
4194 scratch.resvalue = numCols > 0 ? &iresult->value : &state->resvalue;
4195 scratch.resnull = numCols > 0 ? &iresult->isnull : &state->resnull;
4196
4197 ExprEvalPushStep(state, &scratch);
4198
4199 /*
4200 * When using an initial value use the NEXT32 ops as the FIRST ops
4201 * would overwrite the stored initial value.
4202 */
4203 opcode = EEOP_HASHDATUM_NEXT32;
4204 }
4205
4206 for (int i = 0; i < numCols; i++)
4207 {
4208 FmgrInfo *finfo;
4209 FunctionCallInfo fcinfo;
4210 Oid inputcollid = collations[i];
4211 AttrNumber attnum = keyColIdx[i] - 1;
4212
4213 finfo = &hashfunctions[i];
4214 fcinfo = palloc0(SizeForFunctionCallInfo(1));
4215
4216 /* Initialize function call parameter structure too */
4217 InitFunctionCallInfoData(*fcinfo, finfo, 1, inputcollid, NULL, NULL);
4218
4219 /*
4220 * Fetch inner Var for this attnum and store it in the 1st arg of the
4221 * hash func.
4222 */
4223 scratch.opcode = EEOP_INNER_VAR;
4224 scratch.resvalue = &fcinfo->args[0].value;
4225 scratch.resnull = &fcinfo->args[0].isnull;
4226 scratch.d.var.attnum = attnum;
4227 scratch.d.var.vartype = TupleDescAttr(desc, attnum)->atttypid;
4229
4230 ExprEvalPushStep(state, &scratch);
4231
4232 /* Call the hash function */
4233 scratch.opcode = opcode;
4234
4235 if (i == numCols - 1)
4236 {
4237 /*
4238 * The result for hashing the final column is stored in the
4239 * ExprState.
4240 */
4241 scratch.resvalue = &state->resvalue;
4242 scratch.resnull = &state->resnull;
4243 }
4244 else
4245 {
4246 Assert(iresult != NULL);
4247
4248 /* intermediate values are stored in an intermediate result */
4249 scratch.resvalue = &iresult->value;
4250 scratch.resnull = &iresult->isnull;
4251 }
4252
4253 /*
4254 * NEXT32 opcodes need to look at the intermediate result. We might
4255 * as well just set this for all ops. FIRSTs won't look at it.
4256 */
4257 scratch.d.hashdatum.iresult = iresult;
4258
4259 scratch.d.hashdatum.finfo = finfo;
4260 scratch.d.hashdatum.fcinfo_data = fcinfo;
4261 scratch.d.hashdatum.fn_addr = finfo->fn_addr;
4262 scratch.d.hashdatum.jumpdone = -1;
4263
4264 ExprEvalPushStep(state, &scratch);
4265
4266 /* subsequent attnums must be combined with the previous */
4267 opcode = EEOP_HASHDATUM_NEXT32;
4268 }
4269
4270 scratch.resvalue = NULL;
4271 scratch.resnull = NULL;
4272 scratch.opcode = EEOP_DONE_RETURN;
4273 ExprEvalPushStep(state, &scratch);
4274
4276
4277 return state;
4278}
int16 AttrNumber
Definition: attnum.h:21
int16 attnum
Definition: pg_attribute.h:74

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

Referenced by BuildTupleHashTable(), and ExecInitSubPlan().

◆ ExecBuildParamSetEqual()

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

Definition at line 4624 of file execExpr.c.

4631{
4633 ExprEvalStep scratch = {0};
4634 int maxatt = list_length(param_exprs);
4635 List *adjust_jumps = NIL;
4636 ListCell *lc;
4637
4638 state->expr = NULL;
4639 state->flags = EEO_FLAG_IS_QUAL;
4640 state->parent = parent;
4641
4642 scratch.resvalue = &state->resvalue;
4643 scratch.resnull = &state->resnull;
4644
4645 /* push deform steps */
4646 scratch.opcode = EEOP_INNER_FETCHSOME;
4647 scratch.d.fetch.last_var = maxatt;
4648 scratch.d.fetch.fixed = false;
4649 scratch.d.fetch.known_desc = desc;
4650 scratch.d.fetch.kind = lops;
4651 if (ExecComputeSlotInfo(state, &scratch))
4652 ExprEvalPushStep(state, &scratch);
4653
4654 scratch.opcode = EEOP_OUTER_FETCHSOME;
4655 scratch.d.fetch.last_var = maxatt;
4656 scratch.d.fetch.fixed = false;
4657 scratch.d.fetch.known_desc = desc;
4658 scratch.d.fetch.kind = rops;
4659 if (ExecComputeSlotInfo(state, &scratch))
4660 ExprEvalPushStep(state, &scratch);
4661
4662 for (int attno = 0; attno < maxatt; attno++)
4663 {
4664 Form_pg_attribute att = TupleDescAttr(desc, attno);
4665 Oid foid = eqfunctions[attno];
4666 Oid collid = collations[attno];
4667 FmgrInfo *finfo;
4668 FunctionCallInfo fcinfo;
4669 AclResult aclresult;
4670
4671 /* Check permission to call function */
4672 aclresult = object_aclcheck(ProcedureRelationId, foid, GetUserId(), ACL_EXECUTE);
4673 if (aclresult != ACLCHECK_OK)
4674 aclcheck_error(aclresult, OBJECT_FUNCTION, get_func_name(foid));
4675
4677
4678 /* Set up the primary fmgr lookup information */
4679 finfo = palloc0(sizeof(FmgrInfo));
4680 fcinfo = palloc0(SizeForFunctionCallInfo(2));
4681 fmgr_info(foid, finfo);
4682 fmgr_info_set_expr(NULL, finfo);
4683 InitFunctionCallInfoData(*fcinfo, finfo, 2,
4684 collid, NULL, NULL);
4685
4686 /* left arg */
4687 scratch.opcode = EEOP_INNER_VAR;
4688 scratch.d.var.attnum = attno;
4689 scratch.d.var.vartype = att->atttypid;
4691 scratch.resvalue = &fcinfo->args[0].value;
4692 scratch.resnull = &fcinfo->args[0].isnull;
4693 ExprEvalPushStep(state, &scratch);
4694
4695 /* right arg */
4696 scratch.opcode = EEOP_OUTER_VAR;
4697 scratch.d.var.attnum = attno;
4698 scratch.d.var.vartype = att->atttypid;
4700 scratch.resvalue = &fcinfo->args[1].value;
4701 scratch.resnull = &fcinfo->args[1].isnull;
4702 ExprEvalPushStep(state, &scratch);
4703
4704 /* evaluate distinctness */
4705 scratch.opcode = EEOP_NOT_DISTINCT;
4706 scratch.d.func.finfo = finfo;
4707 scratch.d.func.fcinfo_data = fcinfo;
4708 scratch.d.func.fn_addr = finfo->fn_addr;
4709 scratch.d.func.nargs = 2;
4710 scratch.resvalue = &state->resvalue;
4711 scratch.resnull = &state->resnull;
4712 ExprEvalPushStep(state, &scratch);
4713
4714 /* then emit EEOP_QUAL to detect if result is false (or null) */
4715 scratch.opcode = EEOP_QUAL;
4716 scratch.d.qualexpr.jumpdone = -1;
4717 scratch.resvalue = &state->resvalue;
4718 scratch.resnull = &state->resnull;
4719 ExprEvalPushStep(state, &scratch);
4720 adjust_jumps = lappend_int(adjust_jumps,
4721 state->steps_len - 1);
4722 }
4723
4724 /* adjust jump targets */
4725 foreach(lc, adjust_jumps)
4726 {
4727 ExprEvalStep *as = &state->steps[lfirst_int(lc)];
4728
4729 Assert(as->opcode == EEOP_QUAL);
4730 Assert(as->d.qualexpr.jumpdone == -1);
4731 as->d.qualexpr.jumpdone = state->steps_len;
4732 }
4733
4734 scratch.resvalue = NULL;
4735 scratch.resnull = NULL;
4736 scratch.opcode = EEOP_DONE_RETURN;
4737 ExprEvalPushStep(state, &scratch);
4738
4740
4741 return state;
4742}

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

Referenced by ExecInitMemoize().

◆ ExecBuildProjectionInfo()

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

Definition at line 370 of file execExpr.c.

375{
378 ExprEvalStep scratch = {0};
379 ListCell *lc;
380
381 projInfo->pi_exprContext = econtext;
382 /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
383 projInfo->pi_state.type = T_ExprState;
384 state = &projInfo->pi_state;
385 state->expr = (Expr *) targetList;
386 state->parent = parent;
387 state->ext_params = NULL;
388
389 state->resultslot = slot;
390
391 /* Insert setup steps as needed */
392 ExecCreateExprSetupSteps(state, (Node *) targetList);
393
394 /* Now compile each tlist column */
395 foreach(lc, targetList)
396 {
398 Var *variable = NULL;
399 AttrNumber attnum = 0;
400 bool isSafeVar = false;
401
402 /*
403 * If tlist expression is a safe non-system Var, use the fast-path
404 * ASSIGN_*_VAR opcodes. "Safe" means that we don't need to apply
405 * CheckVarSlotCompatibility() during plan startup. If a source slot
406 * was provided, we make the equivalent tests here; if a slot was not
407 * provided, we assume that no check is needed because we're dealing
408 * with a non-relation-scan-level expression.
409 */
410 if (tle->expr != NULL &&
411 IsA(tle->expr, Var) &&
412 ((Var *) tle->expr)->varattno > 0)
413 {
414 /* Non-system Var, but how safe is it? */
415 variable = (Var *) tle->expr;
416 attnum = variable->varattno;
417
418 if (inputDesc == NULL)
419 isSafeVar = true; /* can't check, just assume OK */
420 else if (attnum <= inputDesc->natts)
421 {
422 Form_pg_attribute attr = TupleDescAttr(inputDesc, attnum - 1);
423
424 /*
425 * If user attribute is dropped or has a type mismatch, don't
426 * use ASSIGN_*_VAR. Instead let the normal expression
427 * machinery handle it (which'll possibly error out).
428 */
429 if (!attr->attisdropped && variable->vartype == attr->atttypid)
430 {
431 isSafeVar = true;
432 }
433 }
434 }
435
436 if (isSafeVar)
437 {
438 /* Fast-path: just generate an EEOP_ASSIGN_*_VAR step */
439 switch (variable->varno)
440 {
441 case INNER_VAR:
442 /* get the tuple from the inner node */
444 break;
445
446 case OUTER_VAR:
447 /* get the tuple from the outer node */
449 break;
450
451 /* INDEX_VAR is handled by default case */
452
453 default:
454
455 /*
456 * Get the tuple from the relation being scanned, or the
457 * old/new tuple slot, if old/new values were requested.
458 */
459 switch (variable->varreturningtype)
460 {
463 break;
465 scratch.opcode = EEOP_ASSIGN_OLD_VAR;
466 state->flags |= EEO_FLAG_HAS_OLD;
467 break;
469 scratch.opcode = EEOP_ASSIGN_NEW_VAR;
470 state->flags |= EEO_FLAG_HAS_NEW;
471 break;
472 }
473 break;
474 }
475
476 scratch.d.assign_var.attnum = attnum - 1;
477 scratch.d.assign_var.resultnum = tle->resno - 1;
478 ExprEvalPushStep(state, &scratch);
479 }
480 else
481 {
482 /*
483 * Otherwise, compile the column expression normally.
484 *
485 * We can't tell the expression to evaluate directly into the
486 * result slot, as the result slot (and the exprstate for that
487 * matter) can change between executions. We instead evaluate
488 * into the ExprState's resvalue/resnull and then move.
489 */
491 &state->resvalue, &state->resnull);
492
493 /*
494 * Column might be referenced multiple times in upper nodes, so
495 * force value to R/O - but only if it could be an expanded datum.
496 */
497 if (get_typlen(exprType((Node *) tle->expr)) == -1)
499 else
500 scratch.opcode = EEOP_ASSIGN_TMP;
501 scratch.d.assign_tmp.resultnum = tle->resno - 1;
502 ExprEvalPushStep(state, &scratch);
503 }
504 }
505
506 scratch.opcode = EEOP_DONE_NO_RETURN;
507 ExprEvalPushStep(state, &scratch);
508
510
511 return projInfo;
512}
@ EEOP_ASSIGN_TMP
Definition: execExpr.h:110
@ EEOP_ASSIGN_SCAN_VAR
Definition: execExpr.h:105
@ EEOP_ASSIGN_OUTER_VAR
Definition: execExpr.h:104
@ EEOP_ASSIGN_OLD_VAR
Definition: execExpr.h:106
@ EEOP_ASSIGN_TMP_MAKE_RO
Definition: execExpr.h:112
@ EEOP_ASSIGN_INNER_VAR
Definition: execExpr.h:103
@ EEOP_DONE_NO_RETURN
Definition: execExpr.h:72
@ EEOP_ASSIGN_NEW_VAR
Definition: execExpr.h:107
#define EEO_FLAG_HAS_OLD
Definition: execnodes.h:79
#define EEO_FLAG_HAS_NEW
Definition: execnodes.h:81
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
int16 get_typlen(Oid typid)
Definition: lsyscache.c:2337
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define lfirst_node(type, lc)
Definition: pg_list.h:176
@ VAR_RETURNING_OLD
Definition: primnodes.h:257
@ VAR_RETURNING_NEW
Definition: primnodes.h:258
#define OUTER_VAR
Definition: primnodes.h:243
#define INNER_VAR
Definition: primnodes.h:242
struct ExprEvalStep::@55::@60 assign_tmp
int resultnum
Definition: execExpr.h:358
struct ExprEvalStep::@55::@59 assign_var
NodeTag type
Definition: execnodes.h:89
ExprState pi_state
Definition: execnodes.h:381
ExprContext * pi_exprContext
Definition: execnodes.h:383
Expr * expr
Definition: primnodes.h:2219
AttrNumber resno
Definition: primnodes.h:2221
Definition: primnodes.h:262

References ExprEvalStep::assign_tmp, ExprEvalStep::assign_var, attnum, ExprEvalStep::attnum, ExprEvalStep::d, EEO_FLAG_HAS_NEW, EEO_FLAG_HAS_OLD, EEOP_ASSIGN_INNER_VAR, EEOP_ASSIGN_NEW_VAR, EEOP_ASSIGN_OLD_VAR, EEOP_ASSIGN_OUTER_VAR, EEOP_ASSIGN_SCAN_VAR, EEOP_ASSIGN_TMP, EEOP_ASSIGN_TMP_MAKE_RO, EEOP_DONE_NO_RETURN, ExecCreateExprSetupSteps(), ExecInitExprRec(), ExecReadyExpr(), TargetEntry::expr, ExprEvalPushStep(), exprType(), get_typlen(), if(), INNER_VAR, IsA, lfirst_node, makeNode, ExprEvalStep::opcode, OUTER_VAR, ProjectionInfo::pi_exprContext, ProjectionInfo::pi_state, TargetEntry::resno, ExprEvalStep::resultnum, TupleDescAttr(), ExprState::type, VAR_RETURNING_DEFAULT, VAR_RETURNING_NEW, and VAR_RETURNING_OLD.

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

◆ ExecBuildSlotValueDescription()

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

Definition at line 2467 of file execMain.c.

2472{
2474 StringInfoData collist;
2475 bool write_comma = false;
2476 bool write_comma_collist = false;
2477 int i;
2478 AclResult aclresult;
2479 bool table_perm = false;
2480 bool any_perm = false;
2481
2482 /*
2483 * Check if RLS is enabled and should be active for the relation; if so,
2484 * then don't return anything. Otherwise, go through normal permission
2485 * checks.
2486 */
2487 if (check_enable_rls(reloid, InvalidOid, true) == RLS_ENABLED)
2488 return NULL;
2489
2491
2493
2494 /*
2495 * Check if the user has permissions to see the row. Table-level SELECT
2496 * allows access to all columns. If the user does not have table-level
2497 * SELECT then we check each column and include those the user has SELECT
2498 * rights on. Additionally, we always include columns the user provided
2499 * data for.
2500 */
2501 aclresult = pg_class_aclcheck(reloid, GetUserId(), ACL_SELECT);
2502 if (aclresult != ACLCHECK_OK)
2503 {
2504 /* Set up the buffer for the column list */
2505 initStringInfo(&collist);
2506 appendStringInfoChar(&collist, '(');
2507 }
2508 else
2509 table_perm = any_perm = true;
2510
2511 /* Make sure the tuple is fully deconstructed */
2512 slot_getallattrs(slot);
2513
2514 for (i = 0; i < tupdesc->natts; i++)
2515 {
2516 bool column_perm = false;
2517 char *val;
2518 int vallen;
2519 Form_pg_attribute att = TupleDescAttr(tupdesc, i);
2520
2521 /* ignore dropped columns */
2522 if (att->attisdropped)
2523 continue;
2524
2525 if (!table_perm)
2526 {
2527 /*
2528 * No table-level SELECT, so need to make sure they either have
2529 * SELECT rights on the column or that they have provided the data
2530 * for the column. If not, omit this column from the error
2531 * message.
2532 */
2533 aclresult = pg_attribute_aclcheck(reloid, att->attnum,
2536 modifiedCols) || aclresult == ACLCHECK_OK)
2537 {
2538 column_perm = any_perm = true;
2539
2540 if (write_comma_collist)
2541 appendStringInfoString(&collist, ", ");
2542 else
2543 write_comma_collist = true;
2544
2545 appendStringInfoString(&collist, NameStr(att->attname));
2546 }
2547 }
2548
2549 if (table_perm || column_perm)
2550 {
2551 if (att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
2552 val = "virtual";
2553 else if (slot->tts_isnull[i])
2554 val = "null";
2555 else
2556 {
2557 Oid foutoid;
2558 bool typisvarlena;
2559
2560 getTypeOutputInfo(att->atttypid,
2561 &foutoid, &typisvarlena);
2562 val = OidOutputFunctionCall(foutoid, slot->tts_values[i]);
2563 }
2564
2565 if (write_comma)
2567 else
2568 write_comma = true;
2569
2570 /* truncate if needed */
2571 vallen = strlen(val);
2572 if (vallen <= maxfieldlen)
2573 appendBinaryStringInfo(&buf, val, vallen);
2574 else
2575 {
2576 vallen = pg_mbcliplen(val, vallen, maxfieldlen);
2577 appendBinaryStringInfo(&buf, val, vallen);
2578 appendStringInfoString(&buf, "...");
2579 }
2580 }
2581 }
2582
2583 /* If we end up with zero columns being returned, then return NULL. */
2584 if (!any_perm)
2585 return NULL;
2586
2588
2589 if (!table_perm)
2590 {
2591 appendStringInfoString(&collist, ") = ");
2592 appendBinaryStringInfo(&collist, buf.data, buf.len);
2593
2594 return collist.data;
2595 }
2596
2597 return buf.data;
2598}
AclResult pg_attribute_aclcheck(Oid table_oid, AttrNumber attnum, Oid roleid, AclMode mode)
Definition: aclchk.c:3853
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
Definition: aclchk.c:4024
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
#define NameStr(name)
Definition: c.h:717
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1763
long val
Definition: informix.c:689
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:3047
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:1083
#define ACL_SELECT
Definition: parsenodes.h:77
static char * buf
Definition: pg_test_fsync.c:72
#define InvalidOid
Definition: postgres_ext.h:35
int check_enable_rls(Oid relid, Oid checkAsUser, bool noError)
Definition: rls.c:52
@ RLS_ENABLED
Definition: rls.h:45
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition: stringinfo.c:281
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:242
void initStringInfo(StringInfo str)
Definition: stringinfo.c:97
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
static void slot_getallattrs(TupleTableSlot *slot)
Definition: tuptable.h:372

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(), ExecWithCheckOptions(), and ReportNotNullViolationError().

◆ ExecBuildUpdateProjection()

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

Definition at line 547 of file execExpr.c.

554{
557 int nAssignableCols;
558 bool sawJunk;
559 Bitmapset *assignedCols;
560 ExprSetupInfo deform = {0, 0, 0, 0, 0, NIL};
561 ExprEvalStep scratch = {0};
562 int outerattnum;
563 ListCell *lc,
564 *lc2;
565
566 projInfo->pi_exprContext = econtext;
567 /* We embed ExprState into ProjectionInfo instead of doing extra palloc */
568 projInfo->pi_state.type = T_ExprState;
569 state = &projInfo->pi_state;
570 if (evalTargetList)
571 state->expr = (Expr *) targetList;
572 else
573 state->expr = NULL; /* not used */
574 state->parent = parent;
575 state->ext_params = NULL;
576
577 state->resultslot = slot;
578
579 /*
580 * Examine the targetList to see how many non-junk columns there are, and
581 * to verify that the non-junk columns come before the junk ones.
582 */
583 nAssignableCols = 0;
584 sawJunk = false;
585 foreach(lc, targetList)
586 {
588
589 if (tle->resjunk)
590 sawJunk = true;
591 else
592 {
593 if (sawJunk)
594 elog(ERROR, "subplan target list is out of order");
595 nAssignableCols++;
596 }
597 }
598
599 /* We should have one targetColnos entry per non-junk column */
600 if (nAssignableCols != list_length(targetColnos))
601 elog(ERROR, "targetColnos does not match subplan target list");
602
603 /*
604 * Build a bitmapset of the columns in targetColnos. (We could just use
605 * list_member_int() tests, but that risks O(N^2) behavior with many
606 * columns.)
607 */
608 assignedCols = NULL;
609 foreach(lc, targetColnos)
610 {
611 AttrNumber targetattnum = lfirst_int(lc);
612
613 assignedCols = bms_add_member(assignedCols, targetattnum);
614 }
615
616 /*
617 * We need to insert EEOP_*_FETCHSOME steps to ensure the input tuples are
618 * sufficiently deconstructed. The scan tuple must be deconstructed at
619 * least as far as the last old column we need.
620 */
621 for (int attnum = relDesc->natts; attnum > 0; attnum--)
622 {
623 CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);
624
625 if (attr->attisdropped)
626 continue;
627 if (bms_is_member(attnum, assignedCols))
628 continue;
629 deform.last_scan = attnum;
630 break;
631 }
632
633 /*
634 * If we're actually evaluating the tlist, incorporate its input
635 * requirements too; otherwise, we'll just need to fetch the appropriate
636 * number of columns of the "outer" tuple.
637 */
638 if (evalTargetList)
639 expr_setup_walker((Node *) targetList, &deform);
640 else
641 deform.last_outer = nAssignableCols;
642
644
645 /*
646 * Now generate code to evaluate the tlist's assignable expressions or
647 * fetch them from the outer tuple, incidentally validating that they'll
648 * be of the right data type. The checks above ensure that the forboth()
649 * will iterate over exactly the non-junk columns. Note that we don't
650 * bother evaluating any remaining resjunk columns.
651 */
652 outerattnum = 0;
653 forboth(lc, targetList, lc2, targetColnos)
654 {
656 AttrNumber targetattnum = lfirst_int(lc2);
658
659 Assert(!tle->resjunk);
660
661 /*
662 * Apply sanity checks comparable to ExecCheckPlanOutput().
663 */
664 if (targetattnum <= 0 || targetattnum > relDesc->natts)
666 (errcode(ERRCODE_DATATYPE_MISMATCH),
667 errmsg("table row type and query-specified row type do not match"),
668 errdetail("Query has too many columns.")));
669 attr = TupleDescAttr(relDesc, targetattnum - 1);
670
671 if (attr->attisdropped)
673 (errcode(ERRCODE_DATATYPE_MISMATCH),
674 errmsg("table row type and query-specified row type do not match"),
675 errdetail("Query provides a value for a dropped column at ordinal position %d.",
676 targetattnum)));
677 if (exprType((Node *) tle->expr) != attr->atttypid)
679 (errcode(ERRCODE_DATATYPE_MISMATCH),
680 errmsg("table row type and query-specified row type do not match"),
681 errdetail("Table has type %s at ordinal position %d, but query expects %s.",
682 format_type_be(attr->atttypid),
683 targetattnum,
684 format_type_be(exprType((Node *) tle->expr)))));
685
686 /* OK, generate code to perform the assignment. */
687 if (evalTargetList)
688 {
689 /*
690 * We must evaluate the TLE's expression and assign it. We do not
691 * bother jumping through hoops for "safe" Vars like
692 * ExecBuildProjectionInfo does; this is a relatively less-used
693 * path and it doesn't seem worth expending code for that.
694 */
696 &state->resvalue, &state->resnull);
697 /* Needn't worry about read-only-ness here, either. */
698 scratch.opcode = EEOP_ASSIGN_TMP;
699 scratch.d.assign_tmp.resultnum = targetattnum - 1;
700 ExprEvalPushStep(state, &scratch);
701 }
702 else
703 {
704 /* Just assign from the outer tuple. */
706 scratch.d.assign_var.attnum = outerattnum;
707 scratch.d.assign_var.resultnum = targetattnum - 1;
708 ExprEvalPushStep(state, &scratch);
709 }
710 outerattnum++;
711 }
712
713 /*
714 * Now generate code to copy over any old columns that were not assigned
715 * to, and to ensure that dropped columns are set to NULL.
716 */
717 for (int attnum = 1; attnum <= relDesc->natts; attnum++)
718 {
719 CompactAttribute *attr = TupleDescCompactAttr(relDesc, attnum - 1);
720
721 if (attr->attisdropped)
722 {
723 /* Put a null into the ExprState's resvalue/resnull ... */
724 scratch.opcode = EEOP_CONST;
725 scratch.resvalue = &state->resvalue;
726 scratch.resnull = &state->resnull;
727 scratch.d.constval.value = (Datum) 0;
728 scratch.d.constval.isnull = true;
729 ExprEvalPushStep(state, &scratch);
730 /* ... then assign it to the result slot */
731 scratch.opcode = EEOP_ASSIGN_TMP;
732 scratch.d.assign_tmp.resultnum = attnum - 1;
733 ExprEvalPushStep(state, &scratch);
734 }
735 else if (!bms_is_member(attnum, assignedCols))
736 {
737 /* Certainly the right type, so needn't check */
739 scratch.d.assign_var.attnum = attnum - 1;
740 scratch.d.assign_var.resultnum = attnum - 1;
741 ExprEvalPushStep(state, &scratch);
742 }
743 }
744
745 scratch.opcode = EEOP_DONE_NO_RETURN;
746 ExprEvalPushStep(state, &scratch);
747
749
750 return projInfo;
751}
static void ExecPushExprSetupSteps(ExprState *state, ExprSetupInfo *info)
Definition: execExpr.c:2897
static bool expr_setup_walker(Node *node, ExprSetupInfo *info)
Definition: execExpr.c:2983
@ EEOP_CONST
Definition: execExpr.h:115
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
bool attisdropped
Definition: tupdesc.h:77
struct ExprEvalStep::@55::@62 constval
Datum value
Definition: execExpr.h:381
bool isnull
Definition: execExpr.h:382
AttrNumber last_scan
Definition: execExpr.c:64
AttrNumber last_outer
Definition: execExpr.c:63
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:175

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

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

◆ ExecCheck()

bool ExecCheck ( ExprState state,
ExprContext econtext 
)

Definition at line 872 of file execExpr.c.

873{
874 Datum ret;
875 bool isnull;
876
877 /* short-circuit (here and in ExecInitCheck) for empty restriction list */
878 if (state == NULL)
879 return true;
880
881 /* verify that expression was not compiled using ExecInitQual */
882 Assert(!(state->flags & EEO_FLAG_IS_QUAL));
883
884 ret = ExecEvalExprSwitchContext(state, econtext, &isnull);
885
886 if (isnull)
887 return true;
888
889 return DatumGetBool(ret);
890}
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:458
static bool DatumGetBool(Datum X)
Definition: postgres.h:95

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

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

◆ ExecCheckIndexConstraints()

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

Definition at line 543 of file execIndexing.c.

546{
547 int i;
548 int numIndices;
549 RelationPtr relationDescs;
550 Relation heapRelation;
551 IndexInfo **indexInfoArray;
552 ExprContext *econtext;
554 bool isnull[INDEX_MAX_KEYS];
555 ItemPointerData invalidItemPtr;
556 bool checkedIndex = false;
557
558 ItemPointerSetInvalid(conflictTid);
559 ItemPointerSetInvalid(&invalidItemPtr);
560
561 /*
562 * Get information from the result relation info structure.
563 */
564 numIndices = resultRelInfo->ri_NumIndices;
565 relationDescs = resultRelInfo->ri_IndexRelationDescs;
566 indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
567 heapRelation = resultRelInfo->ri_RelationDesc;
568
569 /*
570 * We will use the EState's per-tuple context for evaluating predicates
571 * and index expressions (creating it if it's not already there).
572 */
573 econtext = GetPerTupleExprContext(estate);
574
575 /* Arrange for econtext's scan tuple to be the tuple under test */
576 econtext->ecxt_scantuple = slot;
577
578 /*
579 * For each index, form index tuple and check if it satisfies the
580 * constraint.
581 */
582 for (i = 0; i < numIndices; i++)
583 {
584 Relation indexRelation = relationDescs[i];
585 IndexInfo *indexInfo;
586 bool satisfiesConstraint;
587
588 if (indexRelation == NULL)
589 continue;
590
591 indexInfo = indexInfoArray[i];
592
593 if (!indexInfo->ii_Unique && !indexInfo->ii_ExclusionOps)
594 continue;
595
596 /* If the index is marked as read-only, ignore it */
597 if (!indexInfo->ii_ReadyForInserts)
598 continue;
599
600 /* When specific arbiter indexes requested, only examine them */
601 if (arbiterIndexes != NIL &&
602 !list_member_oid(arbiterIndexes,
603 indexRelation->rd_index->indexrelid))
604 continue;
605
606 if (!indexRelation->rd_index->indimmediate)
608 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
609 errmsg("ON CONFLICT does not support deferrable unique constraints/exclusion constraints as arbiters"),
610 errtableconstraint(heapRelation,
611 RelationGetRelationName(indexRelation))));
612
613 checkedIndex = true;
614
615 /* Check for partial index */
616 if (indexInfo->ii_Predicate != NIL)
617 {
618 ExprState *predicate;
619
620 /*
621 * If predicate state not set up yet, create it (in the estate's
622 * per-query context)
623 */
624 predicate = indexInfo->ii_PredicateState;
625 if (predicate == NULL)
626 {
627 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
628 indexInfo->ii_PredicateState = predicate;
629 }
630
631 /* Skip this index-update if the predicate isn't satisfied */
632 if (!ExecQual(predicate, econtext))
633 continue;
634 }
635
636 /*
637 * FormIndexDatum fills in its values and isnull parameters with the
638 * appropriate values for the column(s) of the index.
639 */
640 FormIndexDatum(indexInfo,
641 slot,
642 estate,
643 values,
644 isnull);
645
646 satisfiesConstraint =
647 check_exclusion_or_unique_constraint(heapRelation, indexRelation,
648 indexInfo, tupleid,
649 values, isnull, estate, false,
650 CEOUC_WAIT, true,
651 conflictTid);
652 if (!satisfiesConstraint)
653 return false;
654 }
655
656 if (arbiterIndexes != NIL && !checkedIndex)
657 elog(ERROR, "unexpected failure to find arbiter index");
658
659 return true;
660}
ExprState * ExecPrepareQual(List *qual, EState *estate)
Definition: execExpr.c:793
static bool ExecQual(ExprState *state, ExprContext *econtext)
Definition: executor.h:541
void FormIndexDatum(IndexInfo *indexInfo, TupleTableSlot *slot, EState *estate, Datum *values, bool *isnull)
Definition: index.c:2730
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
bool list_member_oid(const List *list, Oid datum)
Definition: list.c:722
#define INDEX_MAX_KEYS
int errtableconstraint(Relation rel, const char *conname)
Definition: relcache.c:6086
bool ii_Unique
Definition: execnodes.h:209
ExprState * ii_PredicateState
Definition: execnodes.h:202
Oid * ii_ExclusionOps
Definition: execnodes.h:203
bool ii_ReadyForInserts
Definition: execnodes.h:211
List * ii_Predicate
Definition: execnodes.h:201
Form_pg_index rd_index
Definition: rel.h:192
int ri_NumIndices
Definition: execnodes.h:478
RelationPtr ri_IndexRelationDescs
Definition: execnodes.h:481
IndexInfo ** ri_IndexRelationInfo
Definition: execnodes.h:484

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 661 of file execMain.c.

663{
664 ListCell *l;
665 bool result = true;
666
667#ifdef USE_ASSERT_CHECKING
668 Bitmapset *indexset = NULL;
669
670 /* Check that rteperminfos is consistent with rangeTable */
671 foreach(l, rangeTable)
672 {
674
675 if (rte->perminfoindex != 0)
676 {
677 /* Sanity checks */
678
679 /*
680 * Only relation RTEs and subquery RTEs that were once relation
681 * RTEs (views) have their perminfoindex set.
682 */
683 Assert(rte->rtekind == RTE_RELATION ||
684 (rte->rtekind == RTE_SUBQUERY &&
685 rte->relkind == RELKIND_VIEW));
686
687 /*
688 * Ensure that we have at least an AccessShareLock on relations
689 * whose permissions need to be checked.
690 *
691 * Skip this check in a parallel worker because locks won't be
692 * taken until ExecInitNode() performs plan initialization.
693 *
694 * XXX: ExecCheckPermissions() in a parallel worker may be
695 * redundant with the checks done in the leader process, so this
696 * should be reviewed to ensure it’s necessary.
697 */
700 true));
701
702 (void) getRTEPermissionInfo(rteperminfos, rte);
703 /* Many-to-one mapping not allowed */
704 Assert(!bms_is_member(rte->perminfoindex, indexset));
705 indexset = bms_add_member(indexset, rte->perminfoindex);
706 }
707 }
708
709 /* All rteperminfos are referenced */
710 Assert(bms_num_members(indexset) == list_length(rteperminfos));
711#endif
712
713 foreach(l, rteperminfos)
714 {
716
717 Assert(OidIsValid(perminfo->relid));
718 result = ExecCheckOneRelPerms(perminfo);
719 if (!result)
720 {
721 if (ereport_on_violation)
724 get_rel_name(perminfo->relid));
725 return false;
726 }
727 }
728
730 result = (*ExecutorCheckPerms_hook) (rangeTable, rteperminfos,
731 ereport_on_violation);
732 return result;
733}
@ ACLCHECK_NO_PRIV
Definition: acl.h:184
int bms_num_members(const Bitmapset *a)
Definition: bitmapset.c:751
static bool ExecCheckOneRelPerms(RTEPermissionInfo *perminfo)
Definition: execMain.c:740
ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook
Definition: execMain.c:76
#define IsParallelWorker()
Definition: parallel.h:60
bool CheckRelationOidLockedByMe(Oid relid, LOCKMODE lockmode, bool orstronger)
Definition: lmgr.c:351
#define AccessShareLock
Definition: lockdefs.h:36
char * get_rel_name(Oid relid)
Definition: lsyscache.c:2068
char get_rel_relkind(Oid relid)
Definition: lsyscache.c:2143
ObjectType get_relkind_objtype(char relkind)
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
@ RTE_SUBQUERY
Definition: parsenodes.h:1027
@ RTE_RELATION
Definition: parsenodes.h:1026
RTEKind rtekind
Definition: parsenodes.h:1061

References AccessShareLock, aclcheck_error(), ACLCHECK_NO_PRIV, Assert(), bms_add_member(), bms_is_member(), bms_num_members(), CheckRelationOidLockedByMe(), ExecCheckOneRelPerms(), ExecutorCheckPerms_hook, get_rel_name(), get_rel_relkind(), get_relkind_objtype(), getRTEPermissionInfo(), IsParallelWorker, lfirst_node, list_length(), OidIsValid, 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 1186 of file execUtils.c.

1187{
1188 int len = 0;
1189 ListCell *tl;
1190
1191 foreach(tl, targetlist)
1192 {
1193 TargetEntry *curTle = lfirst_node(TargetEntry, tl);
1194
1195 if (!curTle->resjunk)
1196 len++;
1197 }
1198 return len;
1199}

References len, and lfirst_node.

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

◆ ExecCleanTypeFromTL()

TupleDesc ExecCleanTypeFromTL ( List targetList)

Definition at line 2139 of file execTuples.c.

2140{
2141 return ExecTypeFromTLInternal(targetList, true);
2142}
static TupleDesc ExecTypeFromTLInternal(List *targetList, bool skipjunk)
Definition: execTuples.c:2145

References ExecTypeFromTLInternal().

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

◆ ExecCloseIndices()

void ExecCloseIndices ( ResultRelInfo resultRelInfo)

Definition at line 239 of file execIndexing.c.

240{
241 int i;
242 int numIndices;
243 RelationPtr indexDescs;
244 IndexInfo **indexInfos;
245
246 numIndices = resultRelInfo->ri_NumIndices;
247 indexDescs = resultRelInfo->ri_IndexRelationDescs;
248 indexInfos = resultRelInfo->ri_IndexRelationInfo;
249
250 for (i = 0; i < numIndices; i++)
251 {
252 /* This Assert will fail if ExecCloseIndices is called twice */
253 Assert(indexDescs[i] != NULL);
254
255 /* Give the index a chance to do some post-insert cleanup */
256 index_insert_cleanup(indexDescs[i], indexInfos[i]);
257
258 /* Drop lock acquired by ExecOpenIndices */
259 index_close(indexDescs[i], RowExclusiveLock);
260
261 /* Mark the index as closed */
262 indexDescs[i] = NULL;
263 }
264
265 /*
266 * We don't attempt to free the IndexInfo data structures or the arrays,
267 * instead assuming that such stuff will be cleaned up automatically in
268 * FreeExecutorState.
269 */
270}
void index_insert_cleanup(Relation indexRelation, IndexInfo *indexInfo)
Definition: indexam.c:241
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:177
#define RowExclusiveLock
Definition: lockdefs.h:38

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

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

◆ ExecCloseRangeTableRelations()

void ExecCloseRangeTableRelations ( EState estate)

Definition at line 1711 of file execMain.c.

1712{
1713 int i;
1714
1715 for (i = 0; i < estate->es_range_table_size; i++)
1716 {
1717 if (estate->es_relations[i])
1718 table_close(estate->es_relations[i], NoLock);
1719 }
1720}
#define NoLock
Definition: lockdefs.h:34
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126

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 1651 of file execMain.c.

1652{
1653 ListCell *l;
1654
1655 /*
1656 * close indexes of result relation(s) if any. (Rels themselves are
1657 * closed in ExecCloseRangeTableRelations())
1658 *
1659 * In addition, close the stub RTs that may be in each resultrel's
1660 * ri_ancestorResultRels.
1661 */
1662 foreach(l, estate->es_opened_result_relations)
1663 {
1664 ResultRelInfo *resultRelInfo = lfirst(l);
1665 ListCell *lc;
1666
1667 ExecCloseIndices(resultRelInfo);
1668 foreach(lc, resultRelInfo->ri_ancestorResultRels)
1669 {
1670 ResultRelInfo *rInfo = lfirst(lc);
1671
1672 /*
1673 * Ancestors with RTI > 0 (should only be the root ancestor) are
1674 * closed by ExecCloseRangeTableRelations.
1675 */
1676 if (rInfo->ri_RangeTableIndex > 0)
1677 continue;
1678
1680 }
1681 }
1682
1683 /* Close any relations that have been opened by ExecGetTriggerResultRel(). */
1684 foreach(l, estate->es_trig_target_relations)
1685 {
1686 ResultRelInfo *resultRelInfo = (ResultRelInfo *) lfirst(l);
1687
1688 /*
1689 * Assert this is a "dummy" ResultRelInfo, see above. Otherwise we
1690 * might be issuing a duplicate close against a Relation opened by
1691 * ExecGetRangeTableRelation.
1692 */
1693 Assert(resultRelInfo->ri_RangeTableIndex == 0);
1694
1695 /*
1696 * Since ExecGetTriggerResultRel doesn't call ExecOpenIndices for
1697 * these rels, we needn't call ExecCloseIndices either.
1698 */
1699 Assert(resultRelInfo->ri_NumIndices == 0);
1700
1701 table_close(resultRelInfo->ri_RelationDesc, NoLock);
1702 }
1703}
void ExecCloseIndices(ResultRelInfo *resultRelInfo)
Definition: execIndexing.c:239
Index ri_RangeTableIndex
Definition: execnodes.h:472
List * ri_ancestorResultRels
Definition: execnodes.h:625

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 604 of file execUtils.c.

606{
607 if (tlist_matches_tupdesc(planstate,
608 planstate->plan->targetlist,
609 varno,
610 inputDesc))
611 {
612 planstate->ps_ProjInfo = NULL;
613 planstate->resultopsset = planstate->scanopsset;
614 planstate->resultopsfixed = planstate->scanopsfixed;
615 planstate->resultops = planstate->scanops;
616 }
617 else
618 {
619 if (!planstate->ps_ResultTupleSlot)
620 {
622 planstate->resultops = &TTSOpsVirtual;
623 planstate->resultopsfixed = true;
624 planstate->resultopsset = true;
625 }
626 ExecAssignProjectionInfo(planstate, inputDesc);
627 }
628}
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
void ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1968
static bool tlist_matches_tupdesc(PlanState *ps, List *tlist, int varno, TupleDesc tupdesc)
Definition: execUtils.c:631
void ExecAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc)
Definition: execUtils.c:584
const TupleTableSlotOps * resultops
Definition: execnodes.h:1236
bool resultopsset
Definition: execnodes.h:1244
const TupleTableSlotOps * scanops
Definition: execnodes.h:1233
bool scanopsset
Definition: execnodes.h:1241
bool scanopsfixed
Definition: execnodes.h:1237
bool resultopsfixed
Definition: execnodes.h:1240

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 2056 of file execMain.c.

2058{
2059 Relation rel = resultRelInfo->ri_RelationDesc;
2060 TupleDesc tupdesc = RelationGetDescr(rel);
2061 TupleConstr *constr = tupdesc->constr;
2062 Bitmapset *modifiedCols;
2063 List *notnull_virtual_attrs = NIL;
2064
2065 Assert(constr); /* we should not be called otherwise */
2066
2067 /*
2068 * Verify not-null constraints.
2069 *
2070 * Not-null constraints on virtual generated columns are collected and
2071 * checked separately below.
2072 */
2073 if (constr->has_not_null)
2074 {
2075 for (AttrNumber attnum = 1; attnum <= tupdesc->natts; attnum++)
2076 {
2077 Form_pg_attribute att = TupleDescAttr(tupdesc, attnum - 1);
2078
2079 if (att->attnotnull && att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
2080 notnull_virtual_attrs = lappend_int(notnull_virtual_attrs, attnum);
2081 else if (att->attnotnull && slot_attisnull(slot, attnum))
2082 ReportNotNullViolationError(resultRelInfo, slot, estate, attnum);
2083 }
2084 }
2085
2086 /*
2087 * Verify not-null constraints on virtual generated column, if any.
2088 */
2089 if (notnull_virtual_attrs)
2090 {
2092
2093 attnum = ExecRelGenVirtualNotNull(resultRelInfo, slot, estate,
2094 notnull_virtual_attrs);
2096 ReportNotNullViolationError(resultRelInfo, slot, estate, attnum);
2097 }
2098
2099 /*
2100 * Verify check constraints.
2101 */
2102 if (rel->rd_rel->relchecks > 0)
2103 {
2104 const char *failed;
2105
2106 if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
2107 {
2108 char *val_desc;
2109 Relation orig_rel = rel;
2110
2111 /*
2112 * If the tuple has been routed, it's been converted to the
2113 * partition's rowtype, which might differ from the root table's.
2114 * We must convert it back to the root table's rowtype so that
2115 * val_desc shown error message matches the input tuple.
2116 */
2117 if (resultRelInfo->ri_RootResultRelInfo)
2118 {
2119 ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
2120 TupleDesc old_tupdesc = RelationGetDescr(rel);
2121 AttrMap *map;
2122
2123 tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
2124 /* a reverse map */
2125 map = build_attrmap_by_name_if_req(old_tupdesc,
2126 tupdesc,
2127 false);
2128
2129 /*
2130 * Partition-specific slot's tupdesc can't be changed, so
2131 * allocate a new one.
2132 */
2133 if (map != NULL)
2134 slot = execute_attr_map_slot(map, slot,
2136 modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
2137 ExecGetUpdatedCols(rootrel, estate));
2138 rel = rootrel->ri_RelationDesc;
2139 }
2140 else
2141 modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
2142 ExecGetUpdatedCols(resultRelInfo, estate));
2144 slot,
2145 tupdesc,
2146 modifiedCols,
2147 64);
2148 ereport(ERROR,
2149 (errcode(ERRCODE_CHECK_VIOLATION),
2150 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
2151 RelationGetRelationName(orig_rel), failed),
2152 val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
2153 errtableconstraint(orig_rel, failed)));
2154 }
2155 }
2156}
AttrMap * build_attrmap_by_name_if_req(TupleDesc indesc, TupleDesc outdesc, bool missing_ok)
Definition: attmap.c:261
#define InvalidAttrNumber
Definition: attnum.h:23
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:251
static void ReportNotNullViolationError(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, int attnum)
Definition: execMain.c:2235
char * ExecBuildSlotValueDescription(Oid reloid, TupleTableSlot *slot, TupleDesc tupdesc, Bitmapset *modifiedCols, int maxfieldlen)
Definition: execMain.c:2467
AttrNumber ExecRelGenVirtualNotNull(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, List *notnull_virtual_attrs)
Definition: execMain.c:2170
static const char * ExecRelCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)
Definition: execMain.c:1854
TupleTableSlot * MakeTupleTableSlot(TupleDesc tupleDesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1301
Bitmapset * ExecGetInsertedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1362
Bitmapset * ExecGetUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1383
#define RelationGetRelid(relation)
Definition: rel.h:516
#define RelationGetDescr(relation)
Definition: rel.h:542
Definition: attmap.h:35
struct ResultRelInfo * ri_RootResultRelInfo
Definition: execnodes.h:615
bool has_not_null
Definition: tupdesc.h:45
TupleConstr * constr
Definition: tupdesc.h:141
TupleTableSlot * execute_attr_map_slot(AttrMap *attrMap, TupleTableSlot *in_slot, TupleTableSlot *out_slot)
Definition: tupconvert.c:192
static bool slot_attisnull(TupleTableSlot *slot, int attnum)
Definition: tuptable.h:385

References Assert(), attnum, bms_union(), build_attrmap_by_name_if_req(), TupleDescData::constr, ereport, errcode(), errdetail(), errmsg(), ERROR, errtableconstraint(), ExecBuildSlotValueDescription(), ExecGetInsertedCols(), ExecGetUpdatedCols(), ExecRelCheck(), ExecRelGenVirtualNotNull(), execute_attr_map_slot(), TupleConstr::has_not_null, InvalidAttrNumber, lappend_int(), MakeTupleTableSlot(), TupleDescData::natts, NIL, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReportNotNullViolationError(), 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 705 of file execUtils.c.

708{
710 TupleDesc tupDesc;
711
712 outerPlan = outerPlanState(scanstate);
713 tupDesc = ExecGetResultType(outerPlan);
714
715 ExecInitScanTupleSlot(estate, scanstate, tupDesc, tts_ops);
716}
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:2000
TupleDesc ExecGetResultType(PlanState *planstate)
Definition: execUtils.c:496
#define outerPlanState(node)
Definition: execnodes.h:1255
#define outerPlan(node)
Definition: plannodes.h:241

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.

48{
49 char *cursor_name;
50 char *table_name;
51 Portal portal;
52 QueryDesc *queryDesc;
53
54 /* Get the cursor name --- may have to look up a parameter reference */
55 if (cexpr->cursor_name)
56 cursor_name = cexpr->cursor_name;
57 else
58 cursor_name = fetch_cursor_param_value(econtext, cexpr->cursor_param);
59
60 /* Fetch table name for possible use in error messages */
61 table_name = get_rel_name(table_oid);
62 if (table_name == NULL)
63 elog(ERROR, "cache lookup failed for relation %u", table_oid);
64
65 /* Find the cursor's portal */
66 portal = GetPortalByName(cursor_name);
67 if (!PortalIsValid(portal))
69 (errcode(ERRCODE_UNDEFINED_CURSOR),
70 errmsg("cursor \"%s\" does not exist", cursor_name)));
71
72 /*
73 * We have to watch out for non-SELECT queries as well as held cursors,
74 * both of which may have null queryDesc.
75 */
76 if (portal->strategy != PORTAL_ONE_SELECT)
78 (errcode(ERRCODE_INVALID_CURSOR_STATE),
79 errmsg("cursor \"%s\" is not a SELECT query",
80 cursor_name)));
81 queryDesc = portal->queryDesc;
82 if (queryDesc == NULL || queryDesc->estate == NULL)
84 (errcode(ERRCODE_INVALID_CURSOR_STATE),
85 errmsg("cursor \"%s\" is held from a previous transaction",
86 cursor_name)));
87
88 /*
89 * We have two different strategies depending on whether the cursor uses
90 * FOR UPDATE/SHARE or not. The reason for supporting both is that the
91 * FOR UPDATE code is able to identify a target table in many cases where
92 * the other code can't, while the non-FOR-UPDATE case allows use of WHERE
93 * CURRENT OF with an insensitive cursor.
94 */
95 if (queryDesc->estate->es_rowmarks)
96 {
97 ExecRowMark *erm;
98 Index i;
99
100 /*
101 * Here, the query must have exactly one FOR UPDATE/SHARE reference to
102 * the target table, and we dig the ctid info out of that.
103 */
104 erm = NULL;
105 for (i = 0; i < queryDesc->estate->es_range_table_size; i++)
106 {
107 ExecRowMark *thiserm = queryDesc->estate->es_rowmarks[i];
108
109 if (thiserm == NULL ||
111 continue; /* ignore non-FOR UPDATE/SHARE items */
112
113 if (thiserm->relid == table_oid)
114 {
115 if (erm)
117 (errcode(ERRCODE_INVALID_CURSOR_STATE),
118 errmsg("cursor \"%s\" has multiple FOR UPDATE/SHARE references to table \"%s\"",
119 cursor_name, table_name)));
120 erm = thiserm;
121 }
122 }
123
124 if (erm == NULL)
126 (errcode(ERRCODE_INVALID_CURSOR_STATE),
127 errmsg("cursor \"%s\" does not have a FOR UPDATE/SHARE reference to table \"%s\"",
128 cursor_name, table_name)));
129
130 /*
131 * The cursor must have a current result row: per the SQL spec, it's
132 * an error if not.
133 */
134 if (portal->atStart || portal->atEnd)
136 (errcode(ERRCODE_INVALID_CURSOR_STATE),
137 errmsg("cursor \"%s\" is not positioned on a row",
138 cursor_name)));
139
140 /* Return the currently scanned TID, if there is one */
141 if (ItemPointerIsValid(&(erm->curCtid)))
142 {
143 *current_tid = erm->curCtid;
144 return true;
145 }
146
147 /*
148 * This table didn't produce the cursor's current row; some other
149 * inheritance child of the same parent must have. Signal caller to
150 * do nothing on this table.
151 */
152 return false;
153 }
154 else
155 {
156 /*
157 * Without FOR UPDATE, we dig through the cursor's plan to find the
158 * scan node. Fail if it's not there or buried underneath
159 * aggregation.
160 */
161 ScanState *scanstate;
162 bool pending_rescan = false;
163
164 scanstate = search_plan_tree(queryDesc->planstate, table_oid,
165 &pending_rescan);
166 if (!scanstate)
168 (errcode(ERRCODE_INVALID_CURSOR_STATE),
169 errmsg("cursor \"%s\" is not a simply updatable scan of table \"%s\"",
170 cursor_name, table_name)));
171
172 /*
173 * The cursor must have a current result row: per the SQL spec, it's
174 * an error if not. We test this at the top level, rather than at the
175 * scan node level, because in inheritance cases any one table scan
176 * could easily not be on a row. We want to return false, not raise
177 * error, if the passed-in table OID is for one of the inactive scans.
178 */
179 if (portal->atStart || portal->atEnd)
181 (errcode(ERRCODE_INVALID_CURSOR_STATE),
182 errmsg("cursor \"%s\" is not positioned on a row",
183 cursor_name)));
184
185 /*
186 * Now OK to return false if we found an inactive scan. It is
187 * inactive either if it's not positioned on a row, or there's a
188 * rescan pending for it.
189 */
190 if (TupIsNull(scanstate->ss_ScanTupleSlot) || pending_rescan)
191 return false;
192
193 /*
194 * Extract TID of the scan's current row. The mechanism for this is
195 * in principle scan-type-dependent, but for most scan types, we can
196 * just dig the TID out of the physical scan tuple.
197 */
198 if (IsA(scanstate, IndexOnlyScanState))
199 {
200 /*
201 * For IndexOnlyScan, the tuple stored in ss_ScanTupleSlot may be
202 * a virtual tuple that does not have the ctid column, so we have
203 * to get the TID from xs_heaptid.
204 */
205 IndexScanDesc scan = ((IndexOnlyScanState *) scanstate)->ioss_ScanDesc;
206
207 *current_tid = scan->xs_heaptid;
208 }
209 else
210 {
211 /*
212 * Default case: try to fetch TID from the scan node's current
213 * tuple. As an extra cross-check, verify tableoid in the current
214 * tuple. If the scan hasn't provided a physical tuple, we have
215 * to fail.
216 */
217 Datum ldatum;
218 bool lisnull;
219 ItemPointer tuple_tid;
220
221#ifdef USE_ASSERT_CHECKING
222 ldatum = slot_getsysattr(scanstate->ss_ScanTupleSlot,
224 &lisnull);
225 if (lisnull)
227 (errcode(ERRCODE_INVALID_CURSOR_STATE),
228 errmsg("cursor \"%s\" is not a simply updatable scan of table \"%s\"",
229 cursor_name, table_name)));
230 Assert(DatumGetObjectId(ldatum) == table_oid);
231#endif
232
233 ldatum = slot_getsysattr(scanstate->ss_ScanTupleSlot,
235 &lisnull);
236 if (lisnull)
238 (errcode(ERRCODE_INVALID_CURSOR_STATE),
239 errmsg("cursor \"%s\" is not a simply updatable scan of table \"%s\"",
240 cursor_name, table_name)));
241 tuple_tid = (ItemPointer) DatumGetPointer(ldatum);
242
243 *current_tid = *tuple_tid;
244 }
245
246 Assert(ItemPointerIsValid(current_tid));
247
248 return true;
249 }
250}
static ScanState * search_plan_tree(PlanState *node, Oid table_oid, bool *pending_rescan)
Definition: execCurrent.c:314
static char * fetch_cursor_param_value(ExprContext *econtext, int paramId)
Definition: execCurrent.c:258
ItemPointerData * ItemPointer
Definition: itemptr.h:49
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Definition: itemptr.h:83
@ PORTAL_ONE_SELECT
Definition: portal.h:91
#define PortalIsValid(p)
Definition: portal.h:212
Portal GetPortalByName(const char *name)
Definition: portalmem.c:130
char * cursor_name
Definition: primnodes.h:2103
ItemPointerData curCtid
Definition: execnodes.h:805
ItemPointerData xs_heaptid
Definition: relscan.h:172
QueryDesc * queryDesc
Definition: portal.h:157
bool atEnd
Definition: portal.h:200
bool atStart
Definition: portal.h:199
PortalStrategy strategy
Definition: portal.h:147
EState * estate
Definition: execdesc.h:49
PlanState * planstate
Definition: execdesc.h:50
#define TableOidAttributeNumber
Definition: sysattr.h:26
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21
static Datum slot_getsysattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:420

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.

563{
564 /*
565 * do nothing when we get to the end of a leaf on tree.
566 */
567 if (node == NULL)
568 return;
569
570 /*
571 * Make sure there's enough stack available. Need to check here, in
572 * addition to ExecProcNode() (via ExecProcNodeFirst()), because it's not
573 * guaranteed that ExecProcNode() is reached for all nodes.
574 */
576
577 if (node->chgParam != NULL)
578 {
579 bms_free(node->chgParam);
580 node->chgParam = NULL;
581 }
582
583 switch (nodeTag(node))
584 {
585 /*
586 * control nodes
587 */
588 case T_ResultState:
589 ExecEndResult((ResultState *) node);
590 break;
591
592 case T_ProjectSetState:
594 break;
595
596 case T_ModifyTableState:
598 break;
599
600 case T_AppendState:
601 ExecEndAppend((AppendState *) node);
602 break;
603
604 case T_MergeAppendState:
606 break;
607
608 case T_RecursiveUnionState:
610 break;
611
612 case T_BitmapAndState:
614 break;
615
616 case T_BitmapOrState:
618 break;
619
620 /*
621 * scan nodes
622 */
623 case T_SeqScanState:
625 break;
626
627 case T_SampleScanState:
629 break;
630
631 case T_GatherState:
632 ExecEndGather((GatherState *) node);
633 break;
634
635 case T_GatherMergeState:
637 break;
638
639 case T_IndexScanState:
641 break;
642
643 case T_IndexOnlyScanState:
645 break;
646
647 case T_BitmapIndexScanState:
649 break;
650
651 case T_BitmapHeapScanState:
653 break;
654
655 case T_TidScanState:
657 break;
658
659 case T_TidRangeScanState:
661 break;
662
663 case T_SubqueryScanState:
665 break;
666
667 case T_FunctionScanState:
669 break;
670
671 case T_TableFuncScanState:
673 break;
674
675 case T_CteScanState:
677 break;
678
679 case T_ForeignScanState:
681 break;
682
683 case T_CustomScanState:
685 break;
686
687 /*
688 * join nodes
689 */
690 case T_NestLoopState:
692 break;
693
694 case T_MergeJoinState:
696 break;
697
698 case T_HashJoinState:
700 break;
701
702 /*
703 * materialization nodes
704 */
705 case T_MaterialState:
707 break;
708
709 case T_SortState:
710 ExecEndSort((SortState *) node);
711 break;
712
713 case T_IncrementalSortState:
715 break;
716
717 case T_MemoizeState:
719 break;
720
721 case T_GroupState:
722 ExecEndGroup((GroupState *) node);
723 break;
724
725 case T_AggState:
726 ExecEndAgg((AggState *) node);
727 break;
728
729 case T_WindowAggState:
731 break;
732
733 case T_UniqueState:
734 ExecEndUnique((UniqueState *) node);
735 break;
736
737 case T_HashState:
738 ExecEndHash((HashState *) node);
739 break;
740
741 case T_SetOpState:
742 ExecEndSetOp((SetOpState *) node);
743 break;
744
745 case T_LockRowsState:
747 break;
748
749 case T_LimitState:
750 ExecEndLimit((LimitState *) node);
751 break;
752
753 /* No clean up actions for these nodes. */
754 case T_ValuesScanState:
755 case T_NamedTuplestoreScanState:
756 case T_WorkTableScanState:
757 break;
758
759 default:
760 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
761 break;
762 }
763}
void bms_free(Bitmapset *a)
Definition: bitmapset.c:239
void ExecEndAgg(AggState *node)
Definition: nodeAgg.c:4400
void ExecEndAppend(AppendState *node)
Definition: nodeAppend.c:401
void ExecEndBitmapAnd(BitmapAndState *node)
void ExecEndBitmapHeapScan(BitmapHeapScanState *node)
void ExecEndBitmapIndexScan(BitmapIndexScanState *node)
void ExecEndBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:196
void ExecEndCteScan(CteScanState *node)
Definition: nodeCtescan.c:288
void ExecEndCustomScan(CustomScanState *node)
Definition: nodeCustom.c:125
void ExecEndForeignScan(ForeignScanState *node)
void ExecEndFunctionScan(FunctionScanState *node)
void ExecEndGatherMerge(GatherMergeState *node)
void ExecEndGather(GatherState *node)
Definition: nodeGather.c:251
void ExecEndGroup(GroupState *node)
Definition: nodeGroup.c:226
void ExecEndHash(HashState *node)
Definition: nodeHash.c:427
void ExecEndHashJoin(HashJoinState *node)
Definition: nodeHashjoin.c:948
void ExecEndIncrementalSort(IncrementalSortState *node)
void ExecEndIndexOnlyScan(IndexOnlyScanState *node)
void ExecEndIndexScan(IndexScanState *node)
void ExecEndLimit(LimitState *node)
Definition: nodeLimit.c:534
void ExecEndLockRows(LockRowsState *node)
Definition: nodeLockRows.c:390
void ExecEndMaterial(MaterialState *node)
Definition: nodeMaterial.c:240
void ExecEndMemoize(MemoizeState *node)
Definition: nodeMemoize.c:1079
void ExecEndMergeAppend(MergeAppendState *node)
void ExecEndMergeJoin(MergeJoinState *node)
void ExecEndModifyTable(ModifyTableState *node)
void ExecEndNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:361
void ExecEndProjectSet(ProjectSetState *node)
void ExecEndRecursiveUnion(RecursiveUnionState *node)
void ExecEndResult(ResultState *node)
Definition: nodeResult.c:240
void ExecEndSampleScan(SampleScanState *node)
void ExecEndSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:289
void ExecEndSetOp(SetOpState *node)
Definition: nodeSetOp.c:681
void ExecEndSort(SortState *node)
Definition: nodeSort.c:301
void ExecEndSubqueryScan(SubqueryScanState *node)
void ExecEndTableFuncScan(TableFuncScanState *node)
void ExecEndTidRangeScan(TidRangeScanState *node)
void ExecEndTidScan(TidScanState *node)
Definition: nodeTidscan.c:470
void ExecEndUnique(UniqueState *node)
Definition: nodeUnique.c:168
void ExecEndWindowAgg(WindowAggState *node)
#define nodeTag(nodeptr)
Definition: nodes.h:139
void check_stack_depth(void)
Definition: stack_depth.c:95

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

◆ ExecEvalExprNoReturn()

static void ExecEvalExprNoReturn ( ExprState state,
ExprContext econtext 
)
inlinestatic

Definition at line 440 of file executor.h.

442{
444
445 retDatum = state->evalfunc(state, econtext, NULL);
446
447 Assert(retDatum == (Datum) 0);
448}
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:224

References Assert(), and PG_USED_FOR_ASSERTS_ONLY.

Referenced by ExecEvalExprNoReturnSwitchContext().

◆ ExecEvalExprNoReturnSwitchContext()

static void ExecEvalExprNoReturnSwitchContext ( ExprState state,
ExprContext econtext 
)
inlinestatic

Definition at line 480 of file executor.h.

482{
483 MemoryContext oldContext;
484
485 oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
486 ExecEvalExprNoReturn(state, econtext);
487 MemoryContextSwitchTo(oldContext);
488}
static void ExecEvalExprNoReturn(ExprState *state, ExprContext *econtext)
Definition: executor.h:440

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

Referenced by advance_aggregates(), and ExecProject().

◆ ExecEvalExprSwitchContext()

◆ ExecFilterJunk()

TupleTableSlot * ExecFilterJunk ( JunkFilter junkfilter,
TupleTableSlot slot 
)

Definition at line 247 of file execJunk.c.

248{
249 TupleTableSlot *resultSlot;
250 AttrNumber *cleanMap;
251 TupleDesc cleanTupType;
252 int cleanLength;
253 int i;
254 Datum *values;
255 bool *isnull;
256 Datum *old_values;
257 bool *old_isnull;
258
259 /*
260 * Extract all the values of the old tuple.
261 */
262 slot_getallattrs(slot);
263 old_values = slot->tts_values;
264 old_isnull = slot->tts_isnull;
265
266 /*
267 * get info from the junk filter
268 */
269 cleanTupType = junkfilter->jf_cleanTupType;
270 cleanLength = cleanTupType->natts;
271 cleanMap = junkfilter->jf_cleanMap;
272 resultSlot = junkfilter->jf_resultSlot;
273
274 /*
275 * Prepare to build a virtual result tuple.
276 */
277 ExecClearTuple(resultSlot);
278 values = resultSlot->tts_values;
279 isnull = resultSlot->tts_isnull;
280
281 /*
282 * Transpose data into proper fields of the new tuple.
283 */
284 for (i = 0; i < cleanLength; i++)
285 {
286 int j = cleanMap[i];
287
288 if (j == 0)
289 {
290 values[i] = (Datum) 0;
291 isnull[i] = true;
292 }
293 else
294 {
295 values[i] = old_values[j - 1];
296 isnull[i] = old_isnull[j - 1];
297 }
298 }
299
300 /*
301 * And return the virtual tuple.
302 */
303 return ExecStoreVirtualTuple(resultSlot);
304}
int j
Definition: isn.c:78
TupleDesc jf_cleanTupType
Definition: execnodes.h:414
TupleTableSlot * jf_resultSlot
Definition: execnodes.h:416
AttrNumber * jf_cleanMap
Definition: execnodes.h:415

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.

211{
212 return ExecFindJunkAttributeInTlist(junkfilter->jf_targetList, attrName);
213}
List * jf_targetList
Definition: execnodes.h:413

References ExecFindJunkAttributeInTlist(), and JunkFilter::jf_targetList.

◆ ExecFindJunkAttributeInTlist()

AttrNumber ExecFindJunkAttributeInTlist ( List targetlist,
const char *  attrName 
)

Definition at line 222 of file execJunk.c.

223{
224 ListCell *t;
225
226 foreach(t, targetlist)
227 {
228 TargetEntry *tle = lfirst(t);
229
230 if (tle->resjunk && tle->resname &&
231 (strcmp(tle->resname, attrName) == 0))
232 {
233 /* We found it ! */
234 return tle->resno;
235 }
236 }
237
238 return InvalidAttrNumber;
239}

References InvalidAttrNumber, lfirst, and TargetEntry::resno.

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

◆ ExecFindRowMark()

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

Definition at line 2632 of file execMain.c.

2633{
2634 if (rti > 0 && rti <= estate->es_range_table_size &&
2635 estate->es_rowmarks != NULL)
2636 {
2637 ExecRowMark *erm = estate->es_rowmarks[rti - 1];
2638
2639 if (erm)
2640 return erm;
2641 }
2642 if (!missing_ok)
2643 elog(ERROR, "failed to find ExecRowMark for rangetable index %u", rti);
2644 return NULL;
2645}

References elog, ERROR, and EState::es_rowmarks.

Referenced by ExecInitLockRows(), and ExecInitModifyTable().

◆ ExecGetAllNullSlot()

TupleTableSlot * ExecGetAllNullSlot ( EState estate,
ResultRelInfo relInfo 
)

Definition at line 1274 of file execUtils.c.

1275{
1276 if (relInfo->ri_AllNullSlot == NULL)
1277 {
1278 Relation rel = relInfo->ri_RelationDesc;
1279 MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1280 TupleTableSlot *slot;
1281
1282 slot = ExecInitExtraTupleSlot(estate,
1283 RelationGetDescr(rel),
1286
1287 relInfo->ri_AllNullSlot = slot;
1288
1289 MemoryContextSwitchTo(oldcontext);
1290 }
1291
1292 return relInfo->ri_AllNullSlot;
1293}
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:2020
TupleTableSlot * ExecStoreAllNullTuple(TupleTableSlot *slot)
Definition: execTuples.c:1765
TupleTableSlot * ri_AllNullSlot
Definition: execnodes.h:525
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
Definition: tableam.c:59

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

Referenced by ExecProcessReturning().

◆ ExecGetAllUpdatedCols()

Bitmapset * ExecGetAllUpdatedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1419 of file execUtils.c.

1420{
1421 Bitmapset *ret;
1422 MemoryContext oldcxt;
1423
1425
1426 ret = bms_union(ExecGetUpdatedCols(relinfo, estate),
1427 ExecGetExtraUpdatedCols(relinfo, estate));
1428
1429 MemoryContextSwitchTo(oldcxt);
1430
1431 return ret;
1432}
Bitmapset * ExecGetExtraUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1404
#define GetPerTupleMemoryContext(estate)
Definition: executor.h:683

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

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

◆ ExecGetAncestorResultRels()

List * ExecGetAncestorResultRels ( EState estate,
ResultRelInfo resultRelInfo 
)

Definition at line 1506 of file execMain.c.

1507{
1508 ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1509 Relation partRel = resultRelInfo->ri_RelationDesc;
1510 Oid rootRelOid;
1511
1512 if (!partRel->rd_rel->relispartition)
1513 elog(ERROR, "cannot find ancestors of a non-partition result relation");
1514 Assert(rootRelInfo != NULL);
1515 rootRelOid = RelationGetRelid(rootRelInfo->ri_RelationDesc);
1516 if (resultRelInfo->ri_ancestorResultRels == NIL)
1517 {
1518 ListCell *lc;
1520 List *ancResultRels = NIL;
1521
1522 foreach(lc, oids)
1523 {
1524 Oid ancOid = lfirst_oid(lc);
1525 Relation ancRel;
1526 ResultRelInfo *rInfo;
1527
1528 /*
1529 * Ignore the root ancestor here, and use ri_RootResultRelInfo
1530 * (below) for it instead. Also, we stop climbing up the
1531 * hierarchy when we find the table that was mentioned in the
1532 * query.
1533 */
1534 if (ancOid == rootRelOid)
1535 break;
1536
1537 /*
1538 * All ancestors up to the root target relation must have been
1539 * locked by the planner or AcquireExecutorLocks().
1540 */
1541 ancRel = table_open(ancOid, NoLock);
1542 rInfo = makeNode(ResultRelInfo);
1543
1544 /* dummy rangetable index */
1545 InitResultRelInfo(rInfo, ancRel, 0, NULL,
1546 estate->es_instrument);
1547 ancResultRels = lappend(ancResultRels, rInfo);
1548 }
1549 ancResultRels = lappend(ancResultRels, rootRelInfo);
1550 resultRelInfo->ri_ancestorResultRels = ancResultRels;
1551 }
1552
1553 /* We must have found some ancestor */
1554 Assert(resultRelInfo->ri_ancestorResultRels != NIL);
1555
1556 return resultRelInfo->ri_ancestorResultRels;
1557}
void InitResultRelInfo(ResultRelInfo *resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo *partition_root_rri, int instrument_options)
Definition: execMain.c:1329
List * lappend(List *list, void *datum)
Definition: list.c:339
List * get_partition_ancestors(Oid relid)
Definition: partition.c:134
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40

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

Referenced by ExecCrossPartitionUpdateForeignKey().

◆ ExecGetChildToRootMap()

TupleConversionMap * ExecGetChildToRootMap ( ResultRelInfo resultRelInfo)

Definition at line 1301 of file execUtils.c.

1302{
1303 /* If we didn't already do so, compute the map for this child. */
1304 if (!resultRelInfo->ri_ChildToRootMapValid)
1305 {
1306 ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1307
1308 if (rootRelInfo)
1309 resultRelInfo->ri_ChildToRootMap =
1311 RelationGetDescr(rootRelInfo->ri_RelationDesc));
1312 else /* this isn't a child result rel */
1313 resultRelInfo->ri_ChildToRootMap = NULL;
1314
1315 resultRelInfo->ri_ChildToRootMapValid = true;
1316 }
1317
1318 return resultRelInfo->ri_ChildToRootMap;
1319}
TupleConversionMap * ri_ChildToRootMap
Definition: execnodes.h:595
bool ri_ChildToRootMapValid
Definition: execnodes.h:596
TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc)
Definition: tupconvert.c:102

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

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

◆ ExecGetCommonChildSlotOps()

const TupleTableSlotOps * ExecGetCommonChildSlotOps ( PlanState ps)

Definition at line 564 of file execUtils.c.

565{
566 PlanState *planstates[2];
567
568 planstates[0] = outerPlanState(ps);
569 planstates[1] = innerPlanState(ps);
570 return ExecGetCommonSlotOps(planstates, 2);
571}
const TupleTableSlotOps * ExecGetCommonSlotOps(PlanState **planstates, int nplans)
Definition: execUtils.c:537
#define innerPlanState(node)
Definition: execnodes.h:1254
struct parser_state ps

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

Referenced by build_hash_table().

◆ ExecGetCommonSlotOps()

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

Definition at line 537 of file execUtils.c.

538{
539 const TupleTableSlotOps *result;
540 bool isfixed;
541
542 if (nplans <= 0)
543 return NULL;
544 result = ExecGetResultSlotOps(planstates[0], &isfixed);
545 if (!isfixed)
546 return NULL;
547 for (int i = 1; i < nplans; i++)
548 {
549 const TupleTableSlotOps *thisops;
550
551 thisops = ExecGetResultSlotOps(planstates[i], &isfixed);
552 if (!isfixed)
553 return NULL;
554 if (result != thisops)
555 return NULL;
556 }
557 return result;
558}
const TupleTableSlotOps * ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
Definition: execUtils.c:505

References ExecGetResultSlotOps(), and i.

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

◆ ExecGetExtraUpdatedCols()

Bitmapset * ExecGetExtraUpdatedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1404 of file execUtils.c.

1405{
1406 /* Compute the info if we didn't already */
1407 if (!relinfo->ri_extraUpdatedCols_valid)
1408 ExecInitGenerated(relinfo, estate, CMD_UPDATE);
1409 return relinfo->ri_extraUpdatedCols;
1410}
void ExecInitGenerated(ResultRelInfo *resultRelInfo, EState *estate, CmdType cmdtype)
bool ri_extraUpdatedCols_valid
Definition: execnodes.h:495
Bitmapset * ri_extraUpdatedCols
Definition: execnodes.h:493

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

Referenced by ExecGetAllUpdatedCols(), and index_unchanged_by_update().

◆ ExecGetInsertedCols()

Bitmapset * ExecGetInsertedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1362 of file execUtils.c.

1363{
1364 RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
1365
1366 if (perminfo == NULL)
1367 return NULL;
1368
1369 /* Map the columns to child's attribute numbers if needed. */
1370 if (relinfo->ri_RootResultRelInfo)
1371 {
1372 TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
1373
1374 if (map)
1375 return execute_attr_map_cols(map->attrMap, perminfo->insertedCols);
1376 }
1377
1378 return perminfo->insertedCols;
1379}
TupleConversionMap * ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate)
Definition: execUtils.c:1327
static RTEPermissionInfo * GetResultRTEPermissionInfo(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1439
Bitmapset * insertedCols
Definition: parsenodes.h:1308
AttrMap * attrMap
Definition: tupconvert.h:28
Bitmapset * execute_attr_map_cols(AttrMap *attrMap, Bitmapset *in_cols)
Definition: tupconvert.c:252

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

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

◆ ExecGetJunkAttribute()

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

Definition at line 222 of file executor.h.

223{
224 Assert(attno > 0);
225 return slot_getattr(slot, attno, isNull);
226}
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition: tuptable.h:399

References Assert(), and slot_getattr().

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

◆ ExecGetRangeTableRelation()

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

Definition at line 826 of file execUtils.c.

827{
828 Relation rel;
829
830 Assert(rti > 0 && rti <= estate->es_range_table_size);
831
832 if (!isResultRel && !bms_is_member(rti, estate->es_unpruned_relids))
833 elog(ERROR, "trying to open a pruned relation");
834
835 rel = estate->es_relations[rti - 1];
836 if (rel == NULL)
837 {
838 /* First time through, so open the relation */
839 RangeTblEntry *rte = exec_rt_fetch(rti, estate);
840
841 Assert(rte->rtekind == RTE_RELATION);
842
843 if (!IsParallelWorker())
844 {
845 /*
846 * In a normal query, we should already have the appropriate lock,
847 * but verify that through an Assert. Since there's already an
848 * Assert inside table_open that insists on holding some lock, it
849 * seems sufficient to check this only when rellockmode is higher
850 * than the minimum.
851 */
852 rel = table_open(rte->relid, NoLock);
853 Assert(rte->rellockmode == AccessShareLock ||
854 CheckRelationLockedByMe(rel, rte->rellockmode, false));
855 }
856 else
857 {
858 /*
859 * If we are a parallel worker, we need to obtain our own local
860 * lock on the relation. This ensures sane behavior in case the
861 * parent process exits before we do.
862 */
863 rel = table_open(rte->relid, rte->rellockmode);
864 }
865
866 estate->es_relations[rti - 1] = rel;
867 }
868
869 return rel;
870}
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition: executor.h:719
bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode, bool orstronger)
Definition: lmgr.c:334
Bitmapset * es_unpruned_relids
Definition: execnodes.h:671

References AccessShareLock, Assert(), bms_is_member(), CheckRelationLockedByMe(), elog, ERROR, EState::es_relations, EState::es_unpruned_relids, exec_rt_fetch(), IsParallelWorker, NoLock, RTE_RELATION, RangeTblEntry::rtekind, and table_open().

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

◆ ExecGetResultRelCheckAsUser()

Oid ExecGetResultRelCheckAsUser ( ResultRelInfo relInfo,
EState estate 
)

Definition at line 1490 of file execUtils.c.

1491{
1492 RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relInfo, estate);
1493
1494 /* XXX - maybe ok to return GetUserId() in this case? */
1495 if (perminfo == NULL)
1496 elog(ERROR, "no RTEPermissionInfo found for result relation with OID %u",
1498
1499 return perminfo->checkAsUser ? perminfo->checkAsUser : GetUserId();
1500}

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

Referenced by create_foreign_modify().

◆ ExecGetResultSlotOps()

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

Definition at line 505 of file execUtils.c.

506{
507 if (planstate->resultopsset && planstate->resultops)
508 {
509 if (isfixed)
510 *isfixed = planstate->resultopsfixed;
511 return planstate->resultops;
512 }
513
514 if (isfixed)
515 {
516 if (planstate->resultopsset)
517 *isfixed = planstate->resultopsfixed;
518 else if (planstate->ps_ResultTupleSlot)
519 *isfixed = TTS_FIXED(planstate->ps_ResultTupleSlot);
520 else
521 *isfixed = false;
522 }
523
524 if (!planstate->ps_ResultTupleSlot)
525 return &TTSOpsVirtual;
526
527 return planstate->ps_ResultTupleSlot->tts_ops;
528}
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:121
#define TTS_FIXED(slot)
Definition: tuptable.h:108

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

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

◆ ExecGetResultType()

◆ ExecGetReturningSlot()

TupleTableSlot * ExecGetReturningSlot ( EState estate,
ResultRelInfo relInfo 
)

Definition at line 1249 of file execUtils.c.

1250{
1251 if (relInfo->ri_ReturningSlot == NULL)
1252 {
1253 Relation rel = relInfo->ri_RelationDesc;
1254 MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1255
1256 relInfo->ri_ReturningSlot =
1258 RelationGetDescr(rel),
1260
1261 MemoryContextSwitchTo(oldcontext);
1262 }
1263
1264 return relInfo->ri_ReturningSlot;
1265}
TupleTableSlot * ri_ReturningSlot
Definition: execnodes.h:522

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

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

◆ ExecGetRootToChildMap()

TupleConversionMap * ExecGetRootToChildMap ( ResultRelInfo resultRelInfo,
EState estate 
)

Definition at line 1327 of file execUtils.c.

1328{
1329 /* Mustn't get called for a non-child result relation. */
1330 Assert(resultRelInfo->ri_RootResultRelInfo);
1331
1332 /* If we didn't already do so, compute the map for this child. */
1333 if (!resultRelInfo->ri_RootToChildMapValid)
1334 {
1335 ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1336 TupleDesc indesc = RelationGetDescr(rootRelInfo->ri_RelationDesc);
1337 TupleDesc outdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
1338 Relation childrel = resultRelInfo->ri_RelationDesc;
1339 AttrMap *attrMap;
1340 MemoryContext oldcontext;
1341
1342 /*
1343 * When this child table is not a partition (!relispartition), it may
1344 * have columns that are not present in the root table, which we ask
1345 * to ignore by passing true for missing_ok.
1346 */
1347 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1348 attrMap = build_attrmap_by_name_if_req(indesc, outdesc,
1349 !childrel->rd_rel->relispartition);
1350 if (attrMap)
1351 resultRelInfo->ri_RootToChildMap =
1352 convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
1353 MemoryContextSwitchTo(oldcontext);
1354 resultRelInfo->ri_RootToChildMapValid = true;
1355 }
1356
1357 return resultRelInfo->ri_RootToChildMap;
1358}
TupleConversionMap * ri_RootToChildMap
Definition: execnodes.h:601
bool ri_RootToChildMapValid
Definition: execnodes.h:602
TupleConversionMap * convert_tuples_by_name_attrmap(TupleDesc indesc, TupleDesc outdesc, AttrMap *attrMap)
Definition: tupconvert.c:124

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

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

◆ ExecGetTriggerNewSlot()

TupleTableSlot * ExecGetTriggerNewSlot ( EState estate,
ResultRelInfo relInfo 
)

Definition at line 1227 of file execUtils.c.

1228{
1229 if (relInfo->ri_TrigNewSlot == NULL)
1230 {
1231 Relation rel = relInfo->ri_RelationDesc;
1232 MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1233
1234 relInfo->ri_TrigNewSlot =
1236 RelationGetDescr(rel),
1238
1239 MemoryContextSwitchTo(oldcontext);
1240 }
1241
1242 return relInfo->ri_TrigNewSlot;
1243}
TupleTableSlot * ri_TrigNewSlot
Definition: execnodes.h:524

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

Referenced by AfterTriggerExecute(), and AfterTriggerSaveEvent().

◆ ExecGetTriggerOldSlot()

TupleTableSlot * ExecGetTriggerOldSlot ( EState estate,
ResultRelInfo relInfo 
)

◆ ExecGetTriggerResultRel()

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

Definition at line 1430 of file execMain.c.

1432{
1433 ResultRelInfo *rInfo;
1434 ListCell *l;
1435 Relation rel;
1436 MemoryContext oldcontext;
1437
1438 /* Search through the query result relations */
1439 foreach(l, estate->es_opened_result_relations)
1440 {
1441 rInfo = lfirst(l);
1442 if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
1443 return rInfo;
1444 }
1445
1446 /*
1447 * Search through the result relations that were created during tuple
1448 * routing, if any.
1449 */
1450 foreach(l, estate->es_tuple_routing_result_relations)
1451 {
1452 rInfo = (ResultRelInfo *) lfirst(l);
1453 if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
1454 return rInfo;
1455 }
1456
1457 /* Nope, but maybe we already made an extra ResultRelInfo for it */
1458 foreach(l, estate->es_trig_target_relations)
1459 {
1460 rInfo = (ResultRelInfo *) lfirst(l);
1461 if (RelationGetRelid(rInfo->ri_RelationDesc) == relid)
1462 return rInfo;
1463 }
1464 /* Nope, so we need a new one */
1465
1466 /*
1467 * Open the target relation's relcache entry. We assume that an
1468 * appropriate lock is still held by the backend from whenever the trigger
1469 * event got queued, so we need take no new lock here. Also, we need not
1470 * recheck the relkind, so no need for CheckValidResultRel.
1471 */
1472 rel = table_open(relid, NoLock);
1473
1474 /*
1475 * Make the new entry in the right context.
1476 */
1477 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1478 rInfo = makeNode(ResultRelInfo);
1479 InitResultRelInfo(rInfo,
1480 rel,
1481 0, /* dummy rangetable index */
1482 rootRelInfo,
1483 estate->es_instrument);
1484 estate->es_trig_target_relations =
1485 lappend(estate->es_trig_target_relations, rInfo);
1486 MemoryContextSwitchTo(oldcontext);
1487
1488 /*
1489 * Currently, we don't need any index information in ResultRelInfos used
1490 * only for triggers, so no need to call ExecOpenIndices.
1491 */
1492
1493 return rInfo;
1494}

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

Referenced by afterTriggerInvokeEvents().

◆ ExecGetUpdatedCols()

Bitmapset * ExecGetUpdatedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1383 of file execUtils.c.

1384{
1385 RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
1386
1387 if (perminfo == NULL)
1388 return NULL;
1389
1390 /* Map the columns to child's attribute numbers if needed. */
1391 if (relinfo->ri_RootResultRelInfo)
1392 {
1393 TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
1394
1395 if (map)
1396 return execute_attr_map_cols(map->attrMap, perminfo->updatedCols);
1397 }
1398
1399 return perminfo->updatedCols;
1400}
Bitmapset * updatedCols
Definition: parsenodes.h:1309

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

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

◆ ExecGetUpdateNewTuple()

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

Definition at line 791 of file nodeModifyTable.c.

794{
795 ProjectionInfo *newProj = relinfo->ri_projectNew;
796 ExprContext *econtext;
797
798 /* Use a few extra Asserts to protect against outside callers */
800 Assert(planSlot != NULL && !TTS_EMPTY(planSlot));
801 Assert(oldSlot != NULL && !TTS_EMPTY(oldSlot));
802
803 econtext = newProj->pi_exprContext;
804 econtext->ecxt_outertuple = planSlot;
805 econtext->ecxt_scantuple = oldSlot;
806 return ExecProject(newProj);
807}
static TupleTableSlot * ExecProject(ProjectionInfo *projInfo)
Definition: executor.h:505
bool ri_projectNewInfoValid
Definition: execnodes.h:504
ProjectionInfo * ri_projectNew
Definition: execnodes.h:498
#define TTS_EMPTY(slot)
Definition: tuptable.h:96

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

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

◆ ExecInitCheck()

ExprState * ExecInitCheck ( List qual,
PlanState parent 
)

Definition at line 315 of file execExpr.c.

316{
317 /* short-circuit (here and in ExecCheck) for empty restriction list */
318 if (qual == NIL)
319 return NULL;
320
321 Assert(IsA(qual, List));
322
323 /*
324 * Just convert the implicit-AND list to an explicit AND (if there's more
325 * than one entry), and compile normally. Unlike ExecQual, we can't
326 * short-circuit on NULL results, so the regular AND behavior is needed.
327 */
328 return ExecInitExpr(make_ands_explicit(qual), parent);
329}
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
Definition: execExpr.c:143
Expr * make_ands_explicit(List *andclauses)
Definition: makefuncs.c:799

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

Referenced by ExecPrepareCheck().

◆ ExecInitExpr()

ExprState * ExecInitExpr ( Expr node,
PlanState parent 
)

Definition at line 143 of file execExpr.c.

144{
146 ExprEvalStep scratch = {0};
147
148 /* Special case: NULL expression produces a NULL ExprState pointer */
149 if (node == NULL)
150 return NULL;
151
152 /* Initialize ExprState with empty step list */
154 state->expr = node;
155 state->parent = parent;
156 state->ext_params = NULL;
157
158 /* Insert setup steps as needed */
160
161 /* Compile the expression proper */
162 ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
163
164 /* Finally, append a DONE step */
165 scratch.opcode = EEOP_DONE_RETURN;
166 ExprEvalPushStep(state, &scratch);
167
169
170 return state;
171}

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

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

◆ ExecInitExprList()

List * ExecInitExprList ( List nodes,
PlanState parent 
)

Definition at line 335 of file execExpr.c.

336{
337 List *result = NIL;
338 ListCell *lc;
339
340 foreach(lc, nodes)
341 {
342 Expr *e = lfirst(lc);
343
344 result = lappend(result, ExecInitExpr(e, parent));
345 }
346
347 return result;
348}
e
Definition: preproc-init.c:82

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

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

◆ ExecInitExprWithParams()

ExprState * ExecInitExprWithParams ( Expr node,
ParamListInfo  ext_params 
)

Definition at line 180 of file execExpr.c.

181{
183 ExprEvalStep scratch = {0};
184
185 /* Special case: NULL expression produces a NULL ExprState pointer */
186 if (node == NULL)
187 return NULL;
188
189 /* Initialize ExprState with empty step list */
191 state->expr = node;
192 state->parent = NULL;
193 state->ext_params = ext_params;
194
195 /* Insert setup steps as needed */
197
198 /* Compile the expression proper */
199 ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
200
201 /* Finally, append a DONE step */
202 scratch.opcode = EEOP_DONE_RETURN;
203 ExprEvalPushStep(state, &scratch);
204
206
207 return state;
208}

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

Referenced by exec_eval_simple_expr(), and InitPartitionPruneContext().

◆ ExecInitExtraTupleSlot()

◆ ExecInitFunctionResultSet()

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

Definition at line 444 of file execSRF.c.

446{
448
449 state->funcReturnsSet = true;
450 state->expr = expr;
451 state->func.fn_oid = InvalidOid;
452
453 /*
454 * Initialize metadata. The expression node could be either a FuncExpr or
455 * an OpExpr.
456 */
457 if (IsA(expr, FuncExpr))
458 {
459 FuncExpr *func = (FuncExpr *) expr;
460
461 state->args = ExecInitExprList(func->args, parent);
462 init_sexpr(func->funcid, func->inputcollid, expr, state, parent,
463 econtext->ecxt_per_query_memory, true, true);
464 }
465 else if (IsA(expr, OpExpr))
466 {
467 OpExpr *op = (OpExpr *) expr;
468
469 state->args = ExecInitExprList(op->args, parent);
470 init_sexpr(op->opfuncid, op->inputcollid, expr, state, parent,
471 econtext->ecxt_per_query_memory, true, true);
472 }
473 else
474 elog(ERROR, "unrecognized node type: %d",
475 (int) nodeTag(expr));
476
477 /* shouldn't get here unless the selected function returns set */
478 Assert(state->func.fn_retset);
479
480 return state;
481}
List * ExecInitExprList(List *nodes, PlanState *parent)
Definition: execExpr.c:335
static void init_sexpr(Oid foid, Oid input_collation, Expr *node, SetExprState *sexpr, PlanState *parent, MemoryContext sexprCxt, bool allowSRF, bool needDescForSRF)
Definition: execSRF.c:696
Oid funcid
Definition: primnodes.h:767
List * args
Definition: primnodes.h:785
List * args
Definition: primnodes.h:853

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

Referenced by ExecInitProjectSet().

◆ ExecInitJunkFilter()

JunkFilter * ExecInitJunkFilter ( List targetList,
TupleTableSlot slot 
)

Definition at line 60 of file execJunk.c.

61{
62 JunkFilter *junkfilter;
63 TupleDesc cleanTupType;
64 int cleanLength;
65 AttrNumber *cleanMap;
66
67 /*
68 * Compute the tuple descriptor for the cleaned tuple.
69 */
70 cleanTupType = ExecCleanTypeFromTL(targetList);
71
72 /*
73 * Use the given slot, or make a new slot if we weren't given one.
74 */
75 if (slot)
76 ExecSetSlotDescriptor(slot, cleanTupType);
77 else
78 slot = MakeSingleTupleTableSlot(cleanTupType, &TTSOpsVirtual);
79
80 /*
81 * Now calculate the mapping between the original tuple's attributes and
82 * the "clean" tuple's attributes.
83 *
84 * The "map" is an array of "cleanLength" attribute numbers, i.e. one
85 * entry for every attribute of the "clean" tuple. The value of this entry
86 * is the attribute number of the corresponding attribute of the
87 * "original" tuple. (Zero indicates a NULL output attribute, but we do
88 * not use that feature in this routine.)
89 */
90 cleanLength = cleanTupType->natts;
91 if (cleanLength > 0)
92 {
93 AttrNumber cleanResno;
94 ListCell *t;
95
96 cleanMap = (AttrNumber *) palloc(cleanLength * sizeof(AttrNumber));
97 cleanResno = 0;
98 foreach(t, targetList)
99 {
100 TargetEntry *tle = lfirst(t);
101
102 if (!tle->resjunk)
103 {
104 cleanMap[cleanResno] = tle->resno;
105 cleanResno++;
106 }
107 }
108 Assert(cleanResno == cleanLength);
109 }
110 else
111 cleanMap = NULL;
112
113 /*
114 * Finally create and initialize the JunkFilter struct.
115 */
116 junkfilter = makeNode(JunkFilter);
117
118 junkfilter->jf_targetList = targetList;
119 junkfilter->jf_cleanTupType = cleanTupType;
120 junkfilter->jf_cleanMap = cleanMap;
121 junkfilter->jf_resultSlot = slot;
122
123 return junkfilter;
124}
TupleDesc ExecCleanTypeFromTL(List *targetList)
Definition: execTuples.c:2139

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

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

◆ ExecInitJunkFilterConversion()

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

Definition at line 137 of file execJunk.c.

140{
141 JunkFilter *junkfilter;
142 int cleanLength;
143 AttrNumber *cleanMap;
144 ListCell *t;
145 int i;
146
147 /*
148 * Use the given slot, or make a new slot if we weren't given one.
149 */
150 if (slot)
151 ExecSetSlotDescriptor(slot, cleanTupType);
152 else
153 slot = MakeSingleTupleTableSlot(cleanTupType, &TTSOpsVirtual);
154
155 /*
156 * Calculate the mapping between the original tuple's attributes and the
157 * "clean" tuple's attributes.
158 *
159 * The "map" is an array of "cleanLength" attribute numbers, i.e. one
160 * entry for every attribute of the "clean" tuple. The value of this entry
161 * is the attribute number of the corresponding attribute of the
162 * "original" tuple. We store zero for any deleted attributes, marking
163 * that a NULL is needed in the output tuple.
164 */
165 cleanLength = cleanTupType->natts;
166 if (cleanLength > 0)
167 {
168 cleanMap = (AttrNumber *) palloc0(cleanLength * sizeof(AttrNumber));
169 t = list_head(targetList);
170 for (i = 0; i < cleanLength; i++)
171 {
172 if (TupleDescCompactAttr(cleanTupType, i)->attisdropped)
173 continue; /* map entry is already zero */
174 for (;;)
175 {
176 TargetEntry *tle = lfirst(t);
177
178 t = lnext(targetList, t);
179 if (!tle->resjunk)
180 {
181 cleanMap[i] = tle->resno;
182 break;
183 }
184 }
185 }
186 }
187 else
188 cleanMap = NULL;
189
190 /*
191 * Finally create and initialize the JunkFilter struct.
192 */
193 junkfilter = makeNode(JunkFilter);
194
195 junkfilter->jf_targetList = targetList;
196 junkfilter->jf_cleanTupType = cleanTupType;
197 junkfilter->jf_cleanMap = cleanMap;
198 junkfilter->jf_resultSlot = slot;
199
200 return junkfilter;
201}
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343

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

Referenced by init_execution_state().

◆ ExecInitNode()

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

Definition at line 142 of file execProcnode.c.

143{
144 PlanState *result;
145 List *subps;
146 ListCell *l;
147
148 /*
149 * do nothing when we get to the end of a leaf on tree.
150 */
151 if (node == NULL)
152 return NULL;
153
154 /*
155 * Make sure there's enough stack available. Need to check here, in
156 * addition to ExecProcNode() (via ExecProcNodeFirst()), to ensure the
157 * stack isn't overrun while initializing the node tree.
158 */
160
161 switch (nodeTag(node))
162 {
163 /*
164 * control nodes
165 */
166 case T_Result:
167 result = (PlanState *) ExecInitResult((Result *) node,
168 estate, eflags);
169 break;
170
171 case T_ProjectSet:
172 result = (PlanState *) ExecInitProjectSet((ProjectSet *) node,
173 estate, eflags);
174 break;
175
176 case T_ModifyTable:
177 result = (PlanState *) ExecInitModifyTable((ModifyTable *) node,
178 estate, eflags);
179 break;
180
181 case T_Append:
182 result = (PlanState *) ExecInitAppend((Append *) node,
183 estate, eflags);
184 break;
185
186 case T_MergeAppend:
187 result = (PlanState *) ExecInitMergeAppend((MergeAppend *) node,
188 estate, eflags);
189 break;
190
191 case T_RecursiveUnion:
192 result = (PlanState *) ExecInitRecursiveUnion((RecursiveUnion *) node,
193 estate, eflags);
194 break;
195
196 case T_BitmapAnd:
197 result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node,
198 estate, eflags);
199 break;
200
201 case T_BitmapOr:
202 result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node,
203 estate, eflags);
204 break;
205
206 /*
207 * scan nodes
208 */
209 case T_SeqScan:
210 result = (PlanState *) ExecInitSeqScan((SeqScan *) node,
211 estate, eflags);
212 break;
213
214 case T_SampleScan:
215 result = (PlanState *) ExecInitSampleScan((SampleScan *) node,
216 estate, eflags);
217 break;
218
219 case T_IndexScan:
220 result = (PlanState *) ExecInitIndexScan((IndexScan *) node,
221 estate, eflags);
222 break;
223
224 case T_IndexOnlyScan:
225 result = (PlanState *) ExecInitIndexOnlyScan((IndexOnlyScan *) node,
226 estate, eflags);
227 break;
228
229 case T_BitmapIndexScan:
231 estate, eflags);
232 break;
233
234 case T_BitmapHeapScan:
235 result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node,
236 estate, eflags);
237 break;
238
239 case T_TidScan:
240 result = (PlanState *) ExecInitTidScan((TidScan *) node,
241 estate, eflags);
242 break;
243
244 case T_TidRangeScan:
245 result = (PlanState *) ExecInitTidRangeScan((TidRangeScan *) node,
246 estate, eflags);
247 break;
248
249 case T_SubqueryScan:
250 result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node,
251 estate, eflags);
252 break;
253
254 case T_FunctionScan:
255 result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node,
256 estate, eflags);
257 break;
258
259 case T_TableFuncScan:
260 result = (PlanState *) ExecInitTableFuncScan((TableFuncScan *) node,
261 estate, eflags);
262 break;
263
264 case T_ValuesScan:
265 result = (PlanState *) ExecInitValuesScan((ValuesScan *) node,
266 estate, eflags);
267 break;
268
269 case T_CteScan:
270 result = (PlanState *) ExecInitCteScan((CteScan *) node,
271 estate, eflags);
272 break;
273
274 case T_NamedTuplestoreScan:
276 estate, eflags);
277 break;
278
279 case T_WorkTableScan:
280 result = (PlanState *) ExecInitWorkTableScan((WorkTableScan *) node,
281 estate, eflags);
282 break;
283
284 case T_ForeignScan:
285 result = (PlanState *) ExecInitForeignScan((ForeignScan *) node,
286 estate, eflags);
287 break;
288
289 case T_CustomScan:
290 result = (PlanState *) ExecInitCustomScan((CustomScan *) node,
291 estate, eflags);
292 break;
293
294 /*
295 * join nodes
296 */
297 case T_NestLoop:
298 result = (PlanState *) ExecInitNestLoop((NestLoop *) node,
299 estate, eflags);
300 break;
301
302 case T_MergeJoin:
303 result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node,
304 estate, eflags);
305 break;
306
307 case T_HashJoin:
308 result = (PlanState *) ExecInitHashJoin((HashJoin *) node,
309 estate, eflags);
310 break;
311
312 /*
313 * materialization nodes
314 */
315 case T_Material:
316 result = (PlanState *) ExecInitMaterial((Material *) node,
317 estate, eflags);
318 break;
319
320 case T_Sort:
321 result = (PlanState *) ExecInitSort((Sort *) node,
322 estate, eflags);
323 break;
324
325 case T_IncrementalSort:
327 estate, eflags);
328 break;
329
330 case T_Memoize:
331 result = (PlanState *) ExecInitMemoize((Memoize *) node, estate,
332 eflags);
333 break;
334
335 case T_Group:
336 result = (PlanState *) ExecInitGroup((Group *) node,
337 estate, eflags);
338 break;
339
340 case T_Agg:
341 result = (PlanState *) ExecInitAgg((Agg *) node,
342 estate, eflags);
343 break;
344
345 case T_WindowAgg:
346 result = (PlanState *) ExecInitWindowAgg((WindowAgg *) node,
347 estate, eflags);
348 break;
349
350 case T_Unique:
351 result = (PlanState *) ExecInitUnique((Unique *) node,
352 estate, eflags);
353 break;
354
355 case T_Gather:
356 result = (PlanState *) ExecInitGather((Gather *) node,
357 estate, eflags);
358 break;
359
360 case T_GatherMerge:
361 result = (PlanState *) ExecInitGatherMerge((GatherMerge *) node,
362 estate, eflags);
363 break;
364
365 case T_Hash:
366 result = (PlanState *) ExecInitHash((Hash *) node,
367 estate, eflags);
368 break;
369
370 case T_SetOp:
371 result = (PlanState *) ExecInitSetOp((SetOp *) node,
372 estate, eflags);
373 break;
374
375 case T_LockRows:
376 result = (PlanState *) ExecInitLockRows((LockRows *) node,
377 estate, eflags);
378 break;
379
380 case T_Limit:
381 result = (PlanState *) ExecInitLimit((Limit *) node,
382 estate, eflags);
383 break;
384
385 default:
386 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
387 result = NULL; /* keep compiler quiet */
388 break;
389 }
390
391 ExecSetExecProcNode(result, result->ExecProcNode);
392
393 /*
394 * Initialize any initPlans present in this node. The planner put them in
395 * a separate list for us.
396 *
397 * The defining characteristic of initplans is that they don't have
398 * arguments, so we don't need to evaluate them (in contrast to
399 * ExecInitSubPlanExpr()).
400 */
401 subps = NIL;
402 foreach(l, node->initPlan)
403 {
404 SubPlan *subplan = (SubPlan *) lfirst(l);
405 SubPlanState *sstate;
406
407 Assert(IsA(subplan, SubPlan));
408 Assert(subplan->args == NIL);
409 sstate = ExecInitSubPlan(subplan, result);
410 subps = lappend(subps, sstate);
411 }
412 result->initPlan = subps;
413
414 /* Set up instrumentation for this node if requested */
415 if (estate->es_instrument)
416 result->instrument = InstrAlloc(1, estate->es_instrument,
417 result->async_capable);
418
419 return result;
420}
void ExecSetExecProcNode(PlanState *node, ExecProcNodeMtd function)
Definition: execProcnode.c:430
Instrumentation * InstrAlloc(int n, int instrument_options, bool async_mode)
Definition: instrument.c:31
AggState * ExecInitAgg(Agg *node, EState *estate, int eflags)
Definition: nodeAgg.c:3279
AppendState * ExecInitAppend(Append *node, EState *estate, int eflags)
Definition: nodeAppend.c:109
BitmapAndState * ExecInitBitmapAnd(BitmapAnd *node, EState *estate, int eflags)
Definition: nodeBitmapAnd.c:55
BitmapHeapScanState * ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags)
BitmapIndexScanState * ExecInitBitmapIndexScan(BitmapIndexScan *node, EState *estate, int eflags)
BitmapOrState * ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)
Definition: nodeBitmapOr.c:56
CteScanState * ExecInitCteScan(CteScan *node, EState *estate, int eflags)
Definition: nodeCtescan.c:175
CustomScanState * ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags)
Definition: nodeCustom.c:26
ForeignScanState * ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags)
FunctionScanState * ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
GatherMergeState * ExecInitGatherMerge(GatherMerge *node, EState *estate, int eflags)
GatherState * ExecInitGather(Gather *node, EState *estate, int eflags)
Definition: nodeGather.c:53
GroupState * ExecInitGroup(Group *node, EState *estate, int eflags)
Definition: nodeGroup.c:161
HashState * ExecInitHash(Hash *node, EState *estate, int eflags)
Definition: nodeHash.c:370
HashJoinState * ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
Definition: nodeHashjoin.c:716
IncrementalSortState * ExecInitIncrementalSort(IncrementalSort *node, EState *estate, int eflags)
IndexOnlyScanState * ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags)
IndexScanState * ExecInitIndexScan(IndexScan *node, EState *estate, int eflags)
LimitState * ExecInitLimit(Limit *node, EState *estate, int eflags)
Definition: nodeLimit.c:447
LockRowsState * ExecInitLockRows(LockRows *node, EState *estate, int eflags)
Definition: nodeLockRows.c:291
MaterialState * ExecInitMaterial(Material *node, EState *estate, int eflags)
Definition: nodeMaterial.c:164
MemoizeState * ExecInitMemoize(Memoize *node, EState *estate, int eflags)
Definition: nodeMemoize.c:951
MergeAppendState * ExecInitMergeAppend(MergeAppend *node, EState *estate, int eflags)
MergeJoinState * ExecInitMergeJoin(MergeJoin *node, EState *estate, int eflags)
ModifyTableState * ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
NamedTuplestoreScanState * ExecInitNamedTuplestoreScan(NamedTuplestoreScan *node, EState *estate, int eflags)
NestLoopState * ExecInitNestLoop(NestLoop *node, EState *estate, int eflags)
Definition: nodeNestloop.c:262
ProjectSetState * ExecInitProjectSet(ProjectSet *node, EState *estate, int eflags)
RecursiveUnionState * ExecInitRecursiveUnion(RecursiveUnion *node, EState *estate, int eflags)
ResultState * ExecInitResult(Result *node, EState *estate, int eflags)
Definition: nodeResult.c:180
SampleScanState * ExecInitSampleScan(SampleScan *node, EState *estate, int eflags)
SeqScanState * ExecInitSeqScan(SeqScan *node, EState *estate, int eflags)
Definition: nodeSeqscan.c:207
SetOpState * ExecInitSetOp(SetOp *node, EState *estate, int eflags)
Definition: nodeSetOp.c:564
SortState * ExecInitSort(Sort *node, EState *estate, int eflags)
Definition: nodeSort.c:221
SubPlanState * ExecInitSubPlan(SubPlan *subplan, PlanState *parent)
Definition: nodeSubplan.c:826
SubqueryScanState * ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
TableFuncScanState * ExecInitTableFuncScan(TableFuncScan *node, EState *estate, int eflags)
TidRangeScanState * ExecInitTidRangeScan(TidRangeScan *node, EState *estate, int eflags)
TidScanState * ExecInitTidScan(TidScan *node, EState *estate, int eflags)
Definition: nodeTidscan.c:488
UniqueState * ExecInitUnique(Unique *node, EState *estate, int eflags)
Definition: nodeUnique.c:114
ValuesScanState * ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags)
WindowAggState * ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags)
WorkTableScanState * ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags)
Instrumentation * instrument
Definition: execnodes.h:1169
List * initPlan
Definition: execnodes.h:1184
bool async_capable
Definition: execnodes.h:1201
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1165
List * initPlan
Definition: plannodes.h:216
List * args
Definition: primnodes.h:1108

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

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

◆ ExecInitNullTupleSlot()

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

Definition at line 2036 of file execTuples.c.

2038{
2039 TupleTableSlot *slot = ExecInitExtraTupleSlot(estate, tupType, tts_ops);
2040
2041 return ExecStoreAllNullTuple(slot);
2042}

References ExecInitExtraTupleSlot(), and ExecStoreAllNullTuple().

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

◆ ExecInitQual()

ExprState * ExecInitQual ( List qual,
PlanState parent 
)

Definition at line 229 of file execExpr.c.

230{
232 ExprEvalStep scratch = {0};
233 List *adjust_jumps = NIL;
234
235 /* short-circuit (here and in ExecQual) for empty restriction list */
236 if (qual == NIL)
237 return NULL;
238
239 Assert(IsA(qual, List));
240
242 state->expr = (Expr *) qual;
243 state->parent = parent;
244 state->ext_params = NULL;
245
246 /* mark expression as to be used with ExecQual() */
247 state->flags = EEO_FLAG_IS_QUAL;
248
249 /* Insert setup steps as needed */
251
252 /*
253 * ExecQual() needs to return false for an expression returning NULL. That
254 * allows us to short-circuit the evaluation the first time a NULL is
255 * encountered. As qual evaluation is a hot-path this warrants using a
256 * special opcode for qual evaluation that's simpler than BOOL_AND (which
257 * has more complex NULL handling).
258 */
259 scratch.opcode = EEOP_QUAL;
260
261 /*
262 * We can use ExprState's resvalue/resnull as target for each qual expr.
263 */
264 scratch.resvalue = &state->resvalue;
265 scratch.resnull = &state->resnull;
266
267 foreach_ptr(Expr, node, qual)
268 {
269 /* first evaluate expression */
270 ExecInitExprRec(node, state, &state->resvalue, &state->resnull);
271
272 /* then emit EEOP_QUAL to detect if it's false (or null) */
273 scratch.d.qualexpr.jumpdone = -1;
274 ExprEvalPushStep(state, &scratch);
275 adjust_jumps = lappend_int(adjust_jumps,
276 state->steps_len - 1);
277 }
278
279 /* adjust jump targets */
280 foreach_int(jump, adjust_jumps)
281 {
282 ExprEvalStep *as = &state->steps[jump];
283
284 Assert(as->opcode == EEOP_QUAL);
285 Assert(as->d.qualexpr.jumpdone == -1);
286 as->d.qualexpr.jumpdone = state->steps_len;
287 }
288
289 /*
290 * At the end, we don't need to do anything more. The last qual expr must
291 * have yielded TRUE, and since its result is stored in the desired output
292 * location, we're done.
293 */
294 scratch.opcode = EEOP_DONE_RETURN;
295 ExprEvalPushStep(state, &scratch);
296
298
299 return state;
300}
#define foreach_ptr(type, var, lst)
Definition: pg_list.h:469
#define foreach_int(var, lst)
Definition: pg_list.h:470

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

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

◆ ExecInitRangeTable()

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

Definition at line 774 of file execUtils.c.

776{
777 /* Remember the range table List as-is */
778 estate->es_range_table = rangeTable;
779
780 /* ... and the RTEPermissionInfo List too */
781 estate->es_rteperminfos = permInfos;
782
783 /* Set size of associated arrays */
784 estate->es_range_table_size = list_length(rangeTable);
785
786 /*
787 * Initialize the bitmapset of RT indexes (es_unpruned_relids)
788 * representing relations that will be scanned during execution. This set
789 * is initially populated by the caller and may be extended later by
790 * ExecDoInitialPruning() to include RT indexes of unpruned leaf
791 * partitions.
792 */
793 estate->es_unpruned_relids = unpruned_relids;
794
795 /*
796 * Allocate an array to store an open Relation corresponding to each
797 * rangetable entry, and initialize entries to NULL. Relations are opened
798 * and stored here as needed.
799 */
800 estate->es_relations = (Relation *)
801 palloc0(estate->es_range_table_size * sizeof(Relation));
802
803 /*
804 * es_result_relations and es_rowmarks are also parallel to
805 * es_range_table, but are allocated only if needed.
806 */
807 estate->es_result_relations = NULL;
808 estate->es_rowmarks = NULL;
809}

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

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

◆ ExecInitResultRelation()

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

Definition at line 881 of file execUtils.c.

883{
884 Relation resultRelationDesc;
885
886 resultRelationDesc = ExecGetRangeTableRelation(estate, rti, true);
887 InitResultRelInfo(resultRelInfo,
888 resultRelationDesc,
889 rti,
890 NULL,
891 estate->es_instrument);
892
893 if (estate->es_result_relations == NULL)
895 palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *));
896 estate->es_result_relations[rti - 1] = resultRelInfo;
897
898 /*
899 * Saving in the list allows to avoid needlessly traversing the whole
900 * array when only a few of its entries are possibly non-NULL.
901 */
903 lappend(estate->es_opened_result_relations, resultRelInfo);
904}
Relation ExecGetRangeTableRelation(EState *estate, Index rti, bool isResultRel)
Definition: execUtils.c:826

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

Referenced by CopyFrom(), and ExecInitModifyTable().

◆ ExecInitResultSlot()

void ExecInitResultSlot ( PlanState planstate,
const TupleTableSlotOps tts_ops 
)

Definition at line 1968 of file execTuples.c.

1969{
1970 TupleTableSlot *slot;
1971
1972 slot = ExecAllocTableSlot(&planstate->state->es_tupleTable,
1973 planstate->ps_ResultTupleDesc, tts_ops);
1974 planstate->ps_ResultTupleSlot = slot;
1975
1976 planstate->resultopsfixed = planstate->ps_ResultTupleDesc != NULL;
1977 planstate->resultops = tts_ops;
1978 planstate->resultopsset = true;
1979}
EState * state
Definition: execnodes.h:1161

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

Referenced by ExecConditionalAssignProjectionInfo(), and ExecInitResultTupleSlotTL().

◆ ExecInitResultTupleSlotTL()

◆ ExecInitResultTypeTL()

◆ ExecInitScanTupleSlot()

◆ ExecInitTableFunctionResult()

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

Definition at line 56 of file execSRF.c.

58{
60
61 state->funcReturnsSet = false;
62 state->expr = expr;
63 state->func.fn_oid = InvalidOid;
64
65 /*
66 * Normally the passed expression tree will be a FuncExpr, since the
67 * grammar only allows a function call at the top level of a table
68 * function reference. However, if the function doesn't return set then
69 * the planner might have replaced the function call via constant-folding
70 * or inlining. So if we see any other kind of expression node, execute
71 * it via the general ExecEvalExpr() code. That code path will not
72 * support set-returning functions buried in the expression, though.
73 */
74 if (IsA(expr, FuncExpr))
75 {
76 FuncExpr *func = (FuncExpr *) expr;
77
78 state->funcReturnsSet = func->funcretset;
79 state->args = ExecInitExprList(func->args, parent);
80
81 init_sexpr(func->funcid, func->inputcollid, expr, state, parent,
82 econtext->ecxt_per_query_memory, func->funcretset, false);
83 }
84 else
85 {
86 state->elidedFuncState = ExecInitExpr(expr, parent);
87 }
88
89 return state;
90}

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

Referenced by ExecInitFunctionScan().

◆ ExecInsertIndexTuples()

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

Definition at line 310 of file execIndexing.c.

318{
319 ItemPointer tupleid = &slot->tts_tid;
320 List *result = NIL;
321 int i;
322 int numIndices;
323 RelationPtr relationDescs;
324 Relation heapRelation;
325 IndexInfo **indexInfoArray;
326 ExprContext *econtext;
328 bool isnull[INDEX_MAX_KEYS];
329
330 Assert(ItemPointerIsValid(tupleid));
331
332 /*
333 * Get information from the result relation info structure.
334 */
335 numIndices = resultRelInfo->ri_NumIndices;
336 relationDescs = resultRelInfo->ri_IndexRelationDescs;
337 indexInfoArray = resultRelInfo->ri_IndexRelationInfo;
338 heapRelation = resultRelInfo->ri_RelationDesc;
339
340 /* Sanity check: slot must belong to the same rel as the resultRelInfo. */
341 Assert(slot->tts_tableOid == RelationGetRelid(heapRelation));
342
343 /*
344 * We will use the EState's per-tuple context for evaluating predicates
345 * and index expressions (creating it if it's not already there).
346 */
347 econtext = GetPerTupleExprContext(estate);
348
349 /* Arrange for econtext's scan tuple to be the tuple under test */
350 econtext->ecxt_scantuple = slot;
351
352 /*
353 * for each index, form and insert the index tuple
354 */
355 for (i = 0; i < numIndices; i++)
356 {
357 Relation indexRelation = relationDescs[i];
358 IndexInfo *indexInfo;
359 bool applyNoDupErr;
360 IndexUniqueCheck checkUnique;
361 bool indexUnchanged;
362 bool satisfiesConstraint;
363
364 if (indexRelation == NULL)
365 continue;
366
367 indexInfo = indexInfoArray[i];
368
369 /* If the index is marked as read-only, ignore it */
370 if (!indexInfo->ii_ReadyForInserts)
371 continue;
372
373 /*
374 * Skip processing of non-summarizing indexes if we only update
375 * summarizing indexes
376 */
377 if (onlySummarizing && !indexInfo->ii_Summarizing)
378 continue;
379
380 /* Check for partial index */
381 if (indexInfo->ii_Predicate != NIL)
382 {
383 ExprState *predicate;
384
385 /*
386 * If predicate state not set up yet, create it (in the estate's
387 * per-query context)
388 */
389 predicate = indexInfo->ii_PredicateState;
390 if (predicate == NULL)
391 {
392 predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
393 indexInfo->ii_PredicateState = predicate;
394 }
395
396 /* Skip this index-update if the predicate isn't satisfied */
397 if (!ExecQual(predicate, econtext))
398 continue;
399 }
400
401 /*
402 * FormIndexDatum fills in its values and isnull parameters with the
403 * appropriate values for the column(s) of the index.
404 */
405 FormIndexDatum(indexInfo,
406 slot,
407 estate,
408 values,
409 isnull);
410
411 /* Check whether to apply noDupErr to this index */
412 applyNoDupErr = noDupErr &&
413 (arbiterIndexes == NIL ||
414 list_member_oid(arbiterIndexes,
415 indexRelation->rd_index->indexrelid));
416
417 /*
418 * The index AM does the actual insertion, plus uniqueness checking.
419 *
420 * For an immediate-mode unique index, we just tell the index AM to
421 * throw error if not unique.
422 *
423 * For a deferrable unique index, we tell the index AM to just detect
424 * possible non-uniqueness, and we add the index OID to the result
425 * list if further checking is needed.
426 *
427 * For a speculative insertion (used by INSERT ... ON CONFLICT), do
428 * the same as for a deferrable unique index.
429 */
430 if (!indexRelation->rd_index->indisunique)
431 checkUnique = UNIQUE_CHECK_NO;
432 else if (applyNoDupErr)
433 checkUnique = UNIQUE_CHECK_PARTIAL;
434 else if (indexRelation->rd_index->indimmediate)
435 checkUnique = UNIQUE_CHECK_YES;
436 else
437 checkUnique = UNIQUE_CHECK_PARTIAL;
438
439 /*
440 * There's definitely going to be an index_insert() call for this
441 * index. If we're being called as part of an UPDATE statement,
442 * consider if the 'indexUnchanged' = true hint should be passed.
443 */
444 indexUnchanged = update && index_unchanged_by_update(resultRelInfo,
445 estate,
446 indexInfo,
447 indexRelation);
448
449 satisfiesConstraint =
450 index_insert(indexRelation, /* index relation */
451 values, /* array of index Datums */
452 isnull, /* null flags */
453 tupleid, /* tid of heap tuple */
454 heapRelation, /* heap relation */
455 checkUnique, /* type of uniqueness check to do */
456 indexUnchanged, /* UPDATE without logical change? */
457 indexInfo); /* index AM may need this */
458
459 /*
460 * If the index has an associated exclusion constraint, check that.
461 * This is simpler than the process for uniqueness checks since we
462 * always insert first and then check. If the constraint is deferred,
463 * we check now anyway, but don't throw error on violation or wait for
464 * a conclusive outcome from a concurrent insertion; instead we'll
465 * queue a recheck event. Similarly, noDupErr callers (speculative
466 * inserters) will recheck later, and wait for a conclusive outcome
467 * then.
468 *
469 * An index for an exclusion constraint can't also be UNIQUE (not an
470 * essential property, we just don't allow it in the grammar), so no
471 * need to preserve the prior state of satisfiesConstraint.
472 */
473 if (indexInfo->ii_ExclusionOps != NULL)
474 {
475 bool violationOK;
476 CEOUC_WAIT_MODE waitMode;
477
478 if (applyNoDupErr)
479 {
480 violationOK = true;
482 }
483 else if (!indexRelation->rd_index->indimmediate)
484 {
485 violationOK = true;
486 waitMode = CEOUC_NOWAIT;
487 }
488 else
489 {
490 violationOK = false;
491 waitMode = CEOUC_WAIT;
492 }
493
494 satisfiesConstraint =
496 indexRelation, indexInfo,
497 tupleid, values, isnull,
498 estate, false,
499 waitMode, violationOK, NULL);
500 }
501
502 if ((checkUnique == UNIQUE_CHECK_PARTIAL ||
503 indexInfo->ii_ExclusionOps != NULL) &&
504 !satisfiesConstraint)
505 {
506 /*
507 * The tuple potentially violates the uniqueness or exclusion
508 * constraint, so make a note of the index so that we can re-check
509 * it later. Speculative inserters are told if there was a
510 * speculative conflict, since that always requires a restart.
511 */
512 result = lappend_oid(result, RelationGetRelid(indexRelation));
513 if (indexRelation->rd_index->indimmediate && specConflict)
514 *specConflict = true;
515 }
516 }
517
518 return result;
519}
static bool index_unchanged_by_update(ResultRelInfo *resultRelInfo, EState *estate, IndexInfo *indexInfo, Relation indexRelation)
CEOUC_WAIT_MODE
Definition: execIndexing.c:123
@ CEOUC_NOWAIT
Definition: execIndexing.c:125
@ CEOUC_LIVELOCK_PREVENTING_WAIT
Definition: execIndexing.c:126
IndexUniqueCheck
Definition: genam.h:139
@ UNIQUE_CHECK_NO
Definition: genam.h:140
@ UNIQUE_CHECK_PARTIAL
Definition: genam.h:142
@ UNIQUE_CHECK_YES
Definition: genam.h:141
bool index_insert(Relation indexRelation, Datum *values, bool *isnull, ItemPointer heap_t_ctid, Relation heapRelation, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
Definition: indexam.c:213
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
bool ii_Summarizing
Definition: execnodes.h:216
Oid tts_tableOid
Definition: tuptable.h:130
ItemPointerData tts_tid
Definition: tuptable.h:129

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

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

◆ ExecLookupResultRelByOid()

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

Definition at line 4420 of file nodeModifyTable.c.

4422{
4423 if (node->mt_resultOidHash)
4424 {
4425 /* Use the pre-built hash table to locate the rel */
4426 MTTargetRelLookup *mtlookup;
4427
4428 mtlookup = (MTTargetRelLookup *)
4429 hash_search(node->mt_resultOidHash, &resultoid, HASH_FIND, NULL);
4430 if (mtlookup)
4431 {
4432 if (update_cache)
4433 {
4434 node->mt_lastResultOid = resultoid;
4435 node->mt_lastResultIndex = mtlookup->relationIndex;
4436 }
4437 return node->resultRelInfo + mtlookup->relationIndex;
4438 }
4439 }
4440 else
4441 {
4442 /* With few target rels, just search the ResultRelInfo array */
4443 for (int ndx = 0; ndx < node->mt_nrels; ndx++)
4444 {
4445 ResultRelInfo *rInfo = node->resultRelInfo + ndx;
4446
4447 if (RelationGetRelid(rInfo->ri_RelationDesc) == resultoid)
4448 {
4449 if (update_cache)
4450 {
4451 node->mt_lastResultOid = resultoid;
4452 node->mt_lastResultIndex = ndx;
4453 }
4454 return rInfo;
4455 }
4456 }
4457 }
4458
4459 if (!missing_ok)
4460 elog(ERROR, "incorrect result relation OID %u", resultoid);
4461 return NULL;
4462}
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
@ HASH_FIND
Definition: hsearch.h:113
ResultRelInfo * resultRelInfo
Definition: execnodes.h:1402
HTAB * mt_resultOidHash
Definition: execnodes.h:1424

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

Referenced by ExecFindPartition(), and ExecModifyTable().

◆ ExecMakeFunctionResultSet()

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

Definition at line 497 of file execSRF.c.

502{
504 Datum result;
505 FunctionCallInfo fcinfo;
507 ReturnSetInfo rsinfo;
508 bool callit;
509 int i;
510
511restart:
512
513 /* Guard against stack overflow due to overly complex expressions */
515
516 /*
517 * If a previous call of the function returned a set result in the form of
518 * a tuplestore, continue reading rows from the tuplestore until it's
519 * empty.
520 */
521 if (fcache->funcResultStore)
522 {
523 TupleTableSlot *slot = fcache->funcResultSlot;
524 MemoryContext oldContext;
525 bool foundTup;
526
527 /*
528 * Have to make sure tuple in slot lives long enough, otherwise
529 * clearing the slot could end up trying to free something already
530 * freed.
531 */
532 oldContext = MemoryContextSwitchTo(slot->tts_mcxt);
533 foundTup = tuplestore_gettupleslot(fcache->funcResultStore, true, false,
534 fcache->funcResultSlot);
535 MemoryContextSwitchTo(oldContext);
536
537 if (foundTup)
538 {
539 *isDone = ExprMultipleResult;
540 if (fcache->funcReturnsTuple)
541 {
542 /* We must return the whole tuple as a Datum. */
543 *isNull = false;
545 }
546 else
547 {
548 /* Extract the first column and return it as a scalar. */
549 return slot_getattr(fcache->funcResultSlot, 1, isNull);
550 }
551 }
552 /* Exhausted the tuplestore, so clean up */
554 fcache->funcResultStore = NULL;
555 *isDone = ExprEndResult;
556 *isNull = true;
557 return (Datum) 0;
558 }
559
560 /*
561 * arguments is a list of expressions to evaluate before passing to the
562 * function manager. We skip the evaluation if it was already done in the
563 * previous call (ie, we are continuing the evaluation of a set-valued
564 * function). Otherwise, collect the current argument values into fcinfo.
565 *
566 * The arguments have to live in a context that lives at least until all
567 * rows from this SRF have been returned, otherwise ValuePerCall SRFs
568 * would reference freed memory after the first returned row.
569 */
570 fcinfo = fcache->fcinfo;
571 arguments = fcache->args;
572 if (!fcache->setArgsValid)
573 {
574 MemoryContext oldContext = MemoryContextSwitchTo(argContext);
575
576 ExecEvalFuncArgs(fcinfo, arguments, econtext);
577 MemoryContextSwitchTo(oldContext);
578 }
579 else
580 {
581 /* Reset flag (we may set it again below) */
582 fcache->setArgsValid = false;
583 }
584
585 /*
586 * Now call the function, passing the evaluated parameter values.
587 */
588
589 /* Prepare a resultinfo node for communication. */
590 fcinfo->resultinfo = (Node *) &rsinfo;
591 rsinfo.type = T_ReturnSetInfo;
592 rsinfo.econtext = econtext;
593 rsinfo.expectedDesc = fcache->funcResultDesc;
595 /* note we do not set SFRM_Materialize_Random or _Preferred */
597 /* isDone is filled below */
598 rsinfo.setResult = NULL;
599 rsinfo.setDesc = NULL;
600
601 /*
602 * If function is strict, and there are any NULL arguments, skip calling
603 * the function.
604 */
605 callit = true;
606 if (fcache->func.fn_strict)
607 {
608 for (i = 0; i < fcinfo->nargs; i++)
609 {
610 if (fcinfo->args[i].isnull)
611 {
612 callit = false;
613 break;
614 }
615 }
616 }
617
618 if (callit)
619 {
620 pgstat_init_function_usage(fcinfo, &fcusage);
621
622 fcinfo->isnull = false;
623 rsinfo.isDone = ExprSingleResult;
624 result = FunctionCallInvoke(fcinfo);
625 *isNull = fcinfo->isnull;
626 *isDone = rsinfo.isDone;
627
629 rsinfo.isDone != ExprMultipleResult);
630 }
631 else
632 {
633 /* for a strict SRF, result for NULL is an empty set */
634 result = (Datum) 0;
635 *isNull = true;
636 *isDone = ExprEndResult;
637 }
638
639 /* Which protocol does function want to use? */
640 if (rsinfo.returnMode == SFRM_ValuePerCall)
641 {
642 if (*isDone != ExprEndResult)
643 {
644 /*
645 * Save the current argument values to re-use on the next call.
646 */
647 if (*isDone == ExprMultipleResult)
648 {
649 fcache->setArgsValid = true;
650 /* Register cleanup callback if we didn't already */
651 if (!fcache->shutdown_reg)
652 {
655 PointerGetDatum(fcache));
656 fcache->shutdown_reg = true;
657 }
658 }
659 }
660 }
661 else if (rsinfo.returnMode == SFRM_Materialize)
662 {
663 /* check we're on the same page as the function author */
664 if (rsinfo.isDone != ExprSingleResult)
666 (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
667 errmsg("table-function protocol for materialize mode was not followed")));
668 if (rsinfo.setResult != NULL)
669 {
670 /* prepare to return values from the tuplestore */
671 ExecPrepareTuplestoreResult(fcache, econtext,
672 rsinfo.setResult,
673 rsinfo.setDesc);
674 /* loop back to top to start returning from tuplestore */
675 goto restart;
676 }
677 /* if setResult was left null, treat it as empty set */
678 *isDone = ExprEndResult;
679 *isNull = true;
680 result = (Datum) 0;
681 }
682 else
684 (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
685 errmsg("unrecognized table-function returnMode: %d",
686 (int) rsinfo.returnMode)));
687
688 return result;
689}
static void ExecEvalFuncArgs(FunctionCallInfo fcinfo, List *argList, ExprContext *econtext)
Definition: execSRF.c:834
static void ShutdownSetExpr(Datum arg)
Definition: execSRF.c:810
static void ExecPrepareTuplestoreResult(SetExprState *sexpr, ExprContext *econtext, Tuplestorestate *resultStore, TupleDesc resultDesc)
Definition: execSRF.c:864
Datum ExecFetchSlotHeapTupleDatum(TupleTableSlot *slot)
Definition: execTuples.c:1912
void RegisterExprContextCallback(ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
Definition: execUtils.c:964
@ ExprSingleResult
Definition: execnodes.h:322
@ ExprMultipleResult
Definition: execnodes.h:323
@ ExprEndResult
Definition: execnodes.h:324
@ SFRM_ValuePerCall
Definition: execnodes.h:335
@ SFRM_Materialize
Definition: execnodes.h:336
#define FunctionCallInvoke(fcinfo)
Definition: fmgr.h:172
void pgstat_init_function_usage(FunctionCallInfo fcinfo, PgStat_FunctionCallUsage *fcu)
void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
bool fn_strict
Definition: fmgr.h:61
fmNodePtr resultinfo
Definition: fmgr.h:89
NodeTag type
Definition: execnodes.h:349
SetFunctionReturnMode returnMode
Definition: execnodes.h:355
ExprContext * econtext
Definition: execnodes.h:351
TupleDesc setDesc
Definition: execnodes.h:359
Tuplestorestate * setResult
Definition: execnodes.h:358
TupleDesc expectedDesc
Definition: execnodes.h:352
int allowedModes
Definition: execnodes.h:353
ExprDoneCond isDone
Definition: execnodes.h:356
FunctionCallInfo fcinfo
Definition: execnodes.h:995
TupleTableSlot * funcResultSlot
Definition: execnodes.h:958
Tuplestorestate * funcResultStore
Definition: execnodes.h:957
bool shutdown_reg
Definition: execnodes.h:988
bool funcReturnsTuple
Definition: execnodes.h:965
TupleDesc funcResultDesc
Definition: execnodes.h:964
FmgrInfo func
Definition: execnodes.h:950
List * args
Definition: execnodes.h:936
bool setArgsValid
Definition: execnodes.h:980
MemoryContext tts_mcxt
Definition: tuptable.h:128
bool tuplestore_gettupleslot(Tuplestorestate *state, bool forward, bool copy, TupleTableSlot *slot)
Definition: tuplestore.c:1130
void tuplestore_end(Tuplestorestate *state)
Definition: tuplestore.c:492

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

Referenced by ExecProjectSRF().

◆ ExecMakeTableFunctionResult()

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

Definition at line 101 of file execSRF.c.

106{
107 Tuplestorestate *tupstore = NULL;
108 TupleDesc tupdesc = NULL;
109 Oid funcrettype;
110 bool returnsTuple;
111 bool returnsSet = false;
112 FunctionCallInfo fcinfo;
114 ReturnSetInfo rsinfo;
115 HeapTupleData tmptup;
116 MemoryContext callerContext;
117 bool first_time = true;
118
119 /*
120 * Execute per-tablefunc actions in appropriate context.
121 *
122 * The FunctionCallInfo needs to live across all the calls to a
123 * ValuePerCall function, so it can't be allocated in the per-tuple
124 * context. Similarly, the function arguments need to be evaluated in a
125 * context that is longer lived than the per-tuple context: The argument
126 * values would otherwise disappear when we reset that context in the
127 * inner loop. As the caller's CurrentMemoryContext is typically a
128 * query-lifespan context, we don't want to leak memory there. We require
129 * the caller to pass a separate memory context that can be used for this,
130 * and can be reset each time through to avoid bloat.
131 */
132 MemoryContextReset(argContext);
133 callerContext = MemoryContextSwitchTo(argContext);
134
135 funcrettype = exprType((Node *) setexpr->expr);
136
137 returnsTuple = type_is_rowtype(funcrettype);
138
139 /*
140 * Prepare a resultinfo node for communication. We always do this even if
141 * not expecting a set result, so that we can pass expectedDesc. In the
142 * generic-expression case, the expression doesn't actually get to see the
143 * resultinfo, but set it up anyway because we use some of the fields as
144 * our own state variables.
145 */
146 rsinfo.type = T_ReturnSetInfo;
147 rsinfo.econtext = econtext;
148 rsinfo.expectedDesc = expectedDesc;
150 if (randomAccess)
153 /* isDone is filled below */
154 rsinfo.setResult = NULL;
155 rsinfo.setDesc = NULL;
156
157 fcinfo = palloc(SizeForFunctionCallInfo(list_length(setexpr->args)));
158
159 /*
160 * Normally the passed expression tree will be a SetExprState, since the
161 * grammar only allows a function call at the top level of a table
162 * function reference. However, if the function doesn't return set then
163 * the planner might have replaced the function call via constant-folding
164 * or inlining. So if we see any other kind of expression node, execute
165 * it via the general ExecEvalExpr() code; the only difference is that we
166 * don't get a chance to pass a special ReturnSetInfo to any functions
167 * buried in the expression.
168 */
169 if (!setexpr->elidedFuncState)
170 {
171 /*
172 * This path is similar to ExecMakeFunctionResultSet.
173 */
174 returnsSet = setexpr->funcReturnsSet;
175 InitFunctionCallInfoData(*fcinfo, &(setexpr->func),
176 list_length(setexpr->args),
177 setexpr->fcinfo->fncollation,
178 NULL, (Node *) &rsinfo);
179 /* evaluate the function's argument list */
180 Assert(CurrentMemoryContext == argContext);
181 ExecEvalFuncArgs(fcinfo, setexpr->args, econtext);
182
183 /*
184 * If function is strict, and there are any NULL arguments, skip
185 * calling the function and act like it returned NULL (or an empty
186 * set, in the returns-set case).
187 */
188 if (setexpr->func.fn_strict)
189 {
190 int i;
191
192 for (i = 0; i < fcinfo->nargs; i++)
193 {
194 if (fcinfo->args[i].isnull)
195 goto no_function_result;
196 }
197 }
198 }
199 else
200 {
201 /* Treat setexpr as a generic expression */
202 InitFunctionCallInfoData(*fcinfo, NULL, 0, InvalidOid, NULL, NULL);
203 }
204
205 /*
206 * Switch to short-lived context for calling the function or expression.
207 */
209
210 /*
211 * Loop to handle the ValuePerCall protocol (which is also the same
212 * behavior needed in the generic ExecEvalExpr path).
213 */
214 for (;;)
215 {
216 Datum result;
217
219
220 /*
221 * Reset per-tuple memory context before each call of the function or
222 * expression. This cleans up any local memory the function may leak
223 * when called.
224 */
225 ResetExprContext(econtext);
226
227 /* Call the function or expression one time */
228 if (!setexpr->elidedFuncState)
229 {
230 pgstat_init_function_usage(fcinfo, &fcusage);
231
232 fcinfo->isnull = false;
233 rsinfo.isDone = ExprSingleResult;
234 result = FunctionCallInvoke(fcinfo);
235
237 rsinfo.isDone != ExprMultipleResult);
238 }
239 else
240 {
241 result =
242 ExecEvalExpr(setexpr->elidedFuncState, econtext, &fcinfo->isnull);
243 rsinfo.isDone = ExprSingleResult;
244 }
245
246 /* Which protocol does function want to use? */
247 if (rsinfo.returnMode == SFRM_ValuePerCall)
248 {
249 /*
250 * Check for end of result set.
251 */
252 if (rsinfo.isDone == ExprEndResult)
253 break;
254
255 /*
256 * If first time through, build tuplestore for result. For a
257 * scalar function result type, also make a suitable tupdesc.
258 */
259 if (first_time)
260 {
261 MemoryContext oldcontext =
263
264 tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
265 rsinfo.setResult = tupstore;
266 if (!returnsTuple)
267 {
268 tupdesc = CreateTemplateTupleDesc(1);
269 TupleDescInitEntry(tupdesc,
270 (AttrNumber) 1,
271 "column",
272 funcrettype,
273 -1,
274 0);
275 rsinfo.setDesc = tupdesc;
276 }
277 MemoryContextSwitchTo(oldcontext);
278 }
279
280 /*
281 * Store current resultset item.
282 */
283 if (returnsTuple)
284 {
285 if (!fcinfo->isnull)
286 {
288
289 if (tupdesc == NULL)
290 {
291 MemoryContext oldcontext =
293
294 /*
295 * This is the first non-NULL result from the
296 * function. Use the type info embedded in the
297 * rowtype Datum to look up the needed tupdesc. Make
298 * a copy for the query.
299 */
302 rsinfo.setDesc = tupdesc;
303 MemoryContextSwitchTo(oldcontext);
304 }
305 else
306 {
307 /*
308 * Verify all later returned rows have same subtype;
309 * necessary in case the type is RECORD.
310 */
311 if (HeapTupleHeaderGetTypeId(td) != tupdesc->tdtypeid ||
312 HeapTupleHeaderGetTypMod(td) != tupdesc->tdtypmod)
314 (errcode(ERRCODE_DATATYPE_MISMATCH),
315 errmsg("rows returned by function are not all of the same row type")));
316 }
317
318 /*
319 * tuplestore_puttuple needs a HeapTuple not a bare
320 * HeapTupleHeader, but it doesn't need all the fields.
321 */
323 tmptup.t_data = td;
324
325 tuplestore_puttuple(tupstore, &tmptup);
326 }
327 else
328 {
329 /*
330 * NULL result from a tuple-returning function; expand it
331 * to a row of all nulls. We rely on the expectedDesc to
332 * form such rows. (Note: this would be problematic if
333 * tuplestore_putvalues saved the tdtypeid/tdtypmod from
334 * the provided descriptor, since that might not match
335 * what we get from the function itself. But it doesn't.)
336 */
337 int natts = expectedDesc->natts;
338 bool *nullflags;
339
340 nullflags = (bool *) palloc(natts * sizeof(bool));
341 memset(nullflags, true, natts * sizeof(bool));
342 tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
343 }
344 }
345 else
346 {
347 /* Scalar-type case: just store the function result */
348 tuplestore_putvalues(tupstore, tupdesc, &result, &fcinfo->isnull);
349 }
350
351 /*
352 * Are we done?
353 */
354 if (rsinfo.isDone != ExprMultipleResult)
355 break;
356
357 /*
358 * Check that set-returning functions were properly declared.
359 * (Note: for historical reasons, we don't complain if a non-SRF
360 * returns ExprEndResult; that's treated as returning NULL.)
361 */
362 if (!returnsSet)
364 (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
365 errmsg("table-function protocol for value-per-call mode was not followed")));
366 }
367 else if (rsinfo.returnMode == SFRM_Materialize)
368 {
369 /* check we're on the same page as the function author */
370 if (!first_time || rsinfo.isDone != ExprSingleResult || !returnsSet)
372 (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
373 errmsg("table-function protocol for materialize mode was not followed")));
374 /* Done evaluating the set result */
375 break;
376 }
377 else
379 (errcode(ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED),
380 errmsg("unrecognized table-function returnMode: %d",
381 (int) rsinfo.returnMode)));
382
383 first_time = false;
384 }
385
386no_function_result:
387
388 /*
389 * If we got nothing from the function (ie, an empty-set or NULL result),
390 * we have to create the tuplestore to return, and if it's a
391 * non-set-returning function then insert a single all-nulls row. As
392 * above, we depend on the expectedDesc to manufacture the dummy row.
393 */
394 if (rsinfo.setResult == NULL)
395 {
396 MemoryContext oldcontext =
398
399 tupstore = tuplestore_begin_heap(randomAccess, false, work_mem);
400 rsinfo.setResult = tupstore;
401 MemoryContextSwitchTo(oldcontext);
402
403 if (!returnsSet)
404 {
405 int natts = expectedDesc->natts;
406 bool *nullflags;
407
408 nullflags = (bool *) palloc(natts * sizeof(bool));
409 memset(nullflags, true, natts * sizeof(bool));
410 tuplestore_putvalues(tupstore, expectedDesc, NULL, nullflags);
411 }
412 }
413
414 /*
415 * If function provided a tupdesc, cross-check it. We only really need to
416 * do this for functions returning RECORD, but might as well do it always.
417 */
418 if (rsinfo.setDesc)
419 {
420 tupledesc_match(expectedDesc, rsinfo.setDesc);
421
422 /*
423 * If it is a dynamically-allocated TupleDesc, free it: it is
424 * typically allocated in a per-query context, so we must avoid
425 * leaking it across multiple usages.
426 */
427 if (rsinfo.setDesc->tdrefcount == -1)
428 FreeTupleDesc(rsinfo.setDesc);
429 }
430
431 MemoryContextSwitchTo(callerContext);
432
433 /* All done, pass back the tuplestore */
434 return rsinfo.setResult;
435}
static void tupledesc_match(TupleDesc dst_tupdesc, TupleDesc src_tupdesc)
Definition: execSRF.c:943
@ SFRM_Materialize_Preferred
Definition: execnodes.h:338
@ SFRM_Materialize_Random
Definition: execnodes.h:337
#define ResetExprContext(econtext)
Definition: executor.h:672
static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:415
#define DatumGetHeapTupleHeader(X)
Definition: fmgr.h:295
static int32 HeapTupleHeaderGetTypMod(const HeapTupleHeaderData *tup)
Definition: htup_details.h:516
static uint32 HeapTupleHeaderGetDatumLength(const HeapTupleHeaderData *tup)
Definition: htup_details.h:492
static Oid HeapTupleHeaderGetTypeId(const HeapTupleHeaderData *tup)
Definition: htup_details.h:504
bool type_is_rowtype(Oid typid)
Definition: lsyscache.c:2795
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
Expr * expr
Definition: execnodes.h:935
bool funcReturnsSet
Definition: execnodes.h:971
ExprState * elidedFuncState
Definition: execnodes.h:943
int tdrefcount
Definition: tupdesc.h:140
int32 tdtypmod
Definition: tupdesc.h:139
Oid tdtypeid
Definition: tupdesc.h:138
void FreeTupleDesc(TupleDesc tupdesc)
Definition: tupdesc.c:495
TupleDesc CreateTemplateTupleDesc(int natts)
Definition: tupdesc.c:175
void TupleDescInitEntry(TupleDesc desc, AttrNumber attributeNumber, const char *attributeName, Oid oidtypeid, int32 typmod, int attdim)
Definition: tupdesc.c:835
Tuplestorestate * tuplestore_begin_heap(bool randomAccess, bool interXact, int maxKBytes)
Definition: tuplestore.c:330
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, const Datum *values, const bool *isnull)
Definition: tuplestore.c:784
void tuplestore_puttuple(Tuplestorestate *state, HeapTuple tuple)
Definition: tuplestore.c:764
TupleDesc lookup_rowtype_tupdesc_copy(Oid type_id, int32 typmod)
Definition: typcache.c:1956

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

Referenced by FunctionNext().

◆ ExecMarkPos()

void ExecMarkPos ( PlanState node)

Definition at line 327 of file execAmi.c.

328{
329 switch (nodeTag(node))
330 {
331 case T_IndexScanState:
333 break;
334
335 case T_IndexOnlyScanState:
337 break;
338
339 case T_CustomScanState:
341 break;
342
343 case T_MaterialState:
345 break;
346
347 case T_SortState:
348 ExecSortMarkPos((SortState *) node);
349 break;
350
351 case T_ResultState:
353 break;
354
355 default:
356 /* don't make hard error unless caller asks to restore... */
357 elog(DEBUG2, "unrecognized node type: %d", (int) nodeTag(node));
358 break;
359 }
360}
#define DEBUG2
Definition: elog.h:29
void ExecCustomMarkPos(CustomScanState *node)
Definition: nodeCustom.c:139
void ExecIndexOnlyMarkPos(IndexOnlyScanState *node)
void ExecIndexMarkPos(IndexScanState *node)
void ExecMaterialMarkPos(MaterialState *node)
Definition: nodeMaterial.c:262
void ExecResultMarkPos(ResultState *node)
Definition: nodeResult.c:146
void ExecSortMarkPos(SortState *node)
Definition: nodeSort.c:329

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

Referenced by ExecMergeJoin(), and ExecResultMarkPos().

◆ ExecMaterializesOutput()

bool ExecMaterializesOutput ( NodeTag  plantype)

Definition at line 636 of file execAmi.c.

637{
638 switch (plantype)
639 {
640 case T_Material:
641 case T_FunctionScan:
642 case T_TableFuncScan:
643 case T_CteScan:
644 case T_NamedTuplestoreScan:
645 case T_WorkTableScan:
646 case T_Sort:
647 return true;
648
649 default:
650 break;
651 }
652
653 return false;
654}

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

◆ ExecOpenIndices()

void ExecOpenIndices ( ResultRelInfo resultRelInfo,
bool  speculative 
)

Definition at line 160 of file execIndexing.c.

161{
162 Relation resultRelation = resultRelInfo->ri_RelationDesc;
163 List *indexoidlist;
164 ListCell *l;
165 int len,
166 i;
167 RelationPtr relationDescs;
168 IndexInfo **indexInfoArray;
169
170 resultRelInfo->ri_NumIndices = 0;
171
172 /* fast path if no indexes */
173 if (!RelationGetForm(resultRelation)->relhasindex)
174 return;
175
176 /*
177 * Get cached list of index OIDs
178 */
179 indexoidlist = RelationGetIndexList(resultRelation);
180 len = list_length(indexoidlist);
181 if (len == 0)
182 return;
183
184 /* This Assert will fail if ExecOpenIndices is called twice */
185 Assert(resultRelInfo->ri_IndexRelationDescs == NULL);
186
187 /*
188 * allocate space for result arrays
189 */
190 relationDescs = (RelationPtr) palloc(len * sizeof(Relation));
191 indexInfoArray = (IndexInfo **) palloc(len * sizeof(IndexInfo *));
192
193 resultRelInfo->ri_NumIndices = len;
194 resultRelInfo->ri_IndexRelationDescs = relationDescs;
195 resultRelInfo->ri_IndexRelationInfo = indexInfoArray;
196
197 /*
198 * For each index, open the index relation and save pg_index info. We
199 * acquire RowExclusiveLock, signifying we will update the index.
200 *
201 * Note: we do this even if the index is not indisready; it's not worth
202 * the trouble to optimize for the case where it isn't.
203 */
204 i = 0;
205 foreach(l, indexoidlist)
206 {
207 Oid indexOid = lfirst_oid(l);
208 Relation indexDesc;
209 IndexInfo *ii;
210
211 indexDesc = index_open(indexOid, RowExclusiveLock);
212
213 /* extract index key information from the index's pg_index info */
214 ii = BuildIndexInfo(indexDesc);
215
216 /*
217 * If the indexes are to be used for speculative insertion or conflict
218 * detection in logical replication, add extra information required by
219 * unique index entries.
220 */
221 if (speculative && ii->ii_Unique && !indexDesc->rd_index->indisexclusion)
222 BuildSpeculativeIndexInfo(indexDesc, ii);
223
224 relationDescs[i] = indexDesc;
225 indexInfoArray[i] = ii;
226 i++;
227 }
228
229 list_free(indexoidlist);
230}
IndexInfo * BuildIndexInfo(Relation index)
Definition: index.c:2428
void BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii)
Definition: index.c:2669
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:133
void list_free(List *list)
Definition: list.c:1546
#define RelationGetForm(relation)
Definition: rel.h:510
List * RelationGetIndexList(Relation relation)
Definition: relcache.c:4819
Relation * RelationPtr
Definition: relcache.h:35

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

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

◆ ExecOpenScanRelation()

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

Definition at line 743 of file execUtils.c.

744{
745 Relation rel;
746
747 /* Open the relation. */
748 rel = ExecGetRangeTableRelation(estate, scanrelid, false);
749
750 /*
751 * Complain if we're attempting a scan of an unscannable relation, except
752 * when the query won't actually be run. This is a slightly klugy place
753 * to do this, perhaps, but there is no better place.
754 */
755 if ((eflags & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA)) == 0 &&
758 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
759 errmsg("materialized view \"%s\" has not been populated",
761 errhint("Use the REFRESH MATERIALIZED VIEW command.")));
762
763 return rel;
764}
#define EXEC_FLAG_WITH_NO_DATA
Definition: executor.h:72
#define EXEC_FLAG_EXPLAIN_ONLY
Definition: executor.h:66
#define RelationIsScannable(relation)
Definition: rel.h:680

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

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

◆ ExecPartitionCheck()

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

Definition at line 1932 of file execMain.c.

1934{
1935 ExprContext *econtext;
1936 bool success;
1937
1938 /*
1939 * If first time through, build expression state tree for the partition
1940 * check expression. (In the corner case where the partition check
1941 * expression is empty, ie there's a default partition and nothing else,
1942 * we'll be fooled into executing this code each time through. But it's
1943 * pretty darn cheap in that case, so we don't worry about it.)
1944 */
1945 if (resultRelInfo->ri_PartitionCheckExpr == NULL)
1946 {
1947 /*
1948 * Ensure that the qual tree and prepared expression are in the
1949 * query-lifespan context.
1950 */
1952 List *qual = RelationGetPartitionQual(resultRelInfo->ri_RelationDesc);
1953
1954 resultRelInfo->ri_PartitionCheckExpr = ExecPrepareCheck(qual, estate);
1955 MemoryContextSwitchTo(oldcxt);
1956 }
1957
1958 /*
1959 * We will use the EState's per-tuple context for evaluating constraint
1960 * expressions (creating it if it's not already there).
1961 */
1962 econtext = GetPerTupleExprContext(estate);
1963
1964 /* Arrange for econtext's scan tuple to be the tuple under test */
1965 econtext->ecxt_scantuple = slot;
1966
1967 /*
1968 * As in case of the cataloged constraints, we treat a NULL result as
1969 * success here, not a failure.
1970 */
1971 success = ExecCheck(resultRelInfo->ri_PartitionCheckExpr, econtext);
1972
1973 /* if asked to emit error, don't actually return on failure */
1974 if (!success && emitError)
1975 ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
1976
1977 return success;
1978}
bool ExecCheck(ExprState *state, ExprContext *econtext)
Definition: execExpr.c:872
ExprState * ExecPrepareCheck(List *qual, EState *estate)
Definition: execExpr.c:816
void ExecPartitionCheckEmitError(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)
Definition: execMain.c:1985
static bool success
Definition: initdb.c:187
List * RelationGetPartitionQual(Relation rel)
Definition: partcache.c:277
ExprState * ri_PartitionCheckExpr
Definition: execnodes.h:587

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

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

◆ ExecPartitionCheckEmitError()

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

Definition at line 1985 of file execMain.c.

1988{
1989 Oid root_relid;
1990 TupleDesc tupdesc;
1991 char *val_desc;
1992 Bitmapset *modifiedCols;
1993
1994 /*
1995 * If the tuple has been routed, it's been converted to the partition's
1996 * rowtype, which might differ from the root table's. We must convert it
1997 * back to the root table's rowtype so that val_desc in the error message
1998 * matches the input tuple.
1999 */
2000 if (resultRelInfo->ri_RootResultRelInfo)
2001 {
2002 ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
2003 TupleDesc old_tupdesc;
2004 AttrMap *map;
2005
2006 root_relid = RelationGetRelid(rootrel->ri_RelationDesc);
2007 tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
2008
2009 old_tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
2010 /* a reverse map */
2011 map = build_attrmap_by_name_if_req(old_tupdesc, tupdesc, false);
2012
2013 /*
2014 * Partition-specific slot's tupdesc can't be changed, so allocate a
2015 * new one.
2016 */
2017 if (map != NULL)
2018 slot = execute_attr_map_slot(map, slot,
2020 modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
2021 ExecGetUpdatedCols(rootrel, estate));
2022 }
2023 else
2024 {
2025 root_relid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
2026 tupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
2027 modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
2028 ExecGetUpdatedCols(resultRelInfo, estate));
2029 }
2030
2031 val_desc = ExecBuildSlotValueDescription(root_relid,
2032 slot,
2033 tupdesc,
2034 modifiedCols,
2035 64);
2036 ereport(ERROR,
2037 (errcode(ERRCODE_CHECK_VIOLATION),
2038 errmsg("new row for relation \"%s\" violates partition constraint",
2040 val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
2041 errtable(resultRelInfo->ri_RelationDesc)));
2042}
int errtable(Relation rel)
Definition: relcache.c:6032

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

Referenced by ExecCrossPartitionUpdate(), and ExecPartitionCheck().

◆ ExecPlanStillValid()

static bool ExecPlanStillValid ( EState estate)
inlinestatic

Definition at line 311 of file executor.h.

312{
313 return estate->es_cachedplan == NULL ? true :
315}
return true
Definition: isn.c:130
static bool CachedPlanValid(CachedPlan *cplan)
Definition: plancache.h:289
CachedPlan * es_cachedplan
Definition: execnodes.h:667

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

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

◆ ExecPrepareCheck()

ExprState * ExecPrepareCheck ( List qual,
EState estate 
)

Definition at line 816 of file execExpr.c.

817{
818 ExprState *result;
819 MemoryContext oldcontext;
820
821 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
822
823 qual = (List *) expression_planner((Expr *) qual);
824
825 result = ExecInitCheck(qual, NULL);
826
827 MemoryContextSwitchTo(oldcontext);
828
829 return result;
830}
ExprState * ExecInitCheck(List *qual, PlanState *parent)
Definition: execExpr.c:315
Expr * expression_planner(Expr *expr)
Definition: planner.c:6645

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

Referenced by ExecPartitionCheck().

◆ ExecPrepareExpr()

ExprState * ExecPrepareExpr ( Expr node,
EState estate 
)

◆ ExecPrepareExprList()

List * ExecPrepareExprList ( List nodes,
EState estate 
)

Definition at line 839 of file execExpr.c.

840{
841 List *result = NIL;
842 MemoryContext oldcontext;
843 ListCell *lc;
844
845 /* Ensure that the list cell nodes are in the right context too */
846 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
847
848 foreach(lc, nodes)
849 {
850 Expr *e = (Expr *) lfirst(lc);
851
852 result = lappend(result, ExecPrepareExpr(e, estate));
853 }
854
855 MemoryContextSwitchTo(oldcontext);
856
857 return result;
858}
ExprState * ExecPrepareExpr(Expr *node, EState *estate)
Definition: execExpr.c:765

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

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

◆ ExecPrepareQual()

ExprState * ExecPrepareQual ( List qual,
EState estate 
)

Definition at line 793 of file execExpr.c.

794{
795 ExprState *result;
796 MemoryContext oldcontext;
797
798 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
799
800 qual = (List *) expression_planner((Expr *) qual);
801
802 result = ExecInitQual(qual, NULL);
803
804 MemoryContextSwitchTo(oldcontext);
805
806 return result;
807}
ExprState * ExecInitQual(List *qual, PlanState *parent)
Definition: execExpr.c:229

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

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

◆ ExecProcNode()

◆ ExecProject()

static TupleTableSlot * ExecProject ( ProjectionInfo projInfo)
inlinestatic

Definition at line 505 of file executor.h.

506{
507 ExprContext *econtext = projInfo->pi_exprContext;
508 ExprState *state = &projInfo->pi_state;
509 TupleTableSlot *slot = state->resultslot;
510
511 /*
512 * Clear any former contents of the result slot. This makes it safe for
513 * us to use the slot's Datum/isnull arrays as workspace.
514 */
515 ExecClearTuple(slot);
516
517 /* Run the expression */
519
520 /*
521 * Successfully formed a result row. Mark the result slot as containing a
522 * valid virtual tuple (inlined version of ExecStoreVirtualTuple()).
523 */
524 slot->tts_flags &= ~TTS_FLAG_EMPTY;
525 slot->tts_nvalid = slot->tts_tupleDescriptor->natts;
526
527 return slot;
528}
static void ExecEvalExprNoReturnSwitchContext(ExprState *state, ExprContext *econtext)
Definition: executor.h:480
AttrNumber tts_nvalid
Definition: tuptable.h:120
uint16 tts_flags
Definition: tuptable.h:118

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

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

◆ ExecQual()

static bool ExecQual ( ExprState state,
ExprContext econtext 
)
inlinestatic

Definition at line 541 of file executor.h.

542{
543 Datum ret;
544 bool isnull;
545
546 /* short-circuit (here and in ExecInitQual) for empty restriction list */
547 if (state == NULL)
548 return true;
549
550 /* verify that expression was compiled using ExecInitQual */
551 Assert(state->flags & EEO_FLAG_IS_QUAL);
552
553 ret = ExecEvalExprSwitchContext(state, econtext, &isnull);
554
555 /* EEOP_QUAL should never return NULL */
556 Assert(!isnull);
557
558 return DatumGetBool(ret);
559}

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

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

◆ ExecQualAndReset()

static bool ExecQualAndReset ( ExprState state,
ExprContext econtext 
)
inlinestatic

◆ ExecRelationIsTargetRelation()

bool ExecRelationIsTargetRelation ( EState estate,
Index  scanrelid 
)

Definition at line 730 of file execUtils.c.

731{
732 return list_member_int(estate->es_plannedstmt->resultRelations, scanrelid);
733}
bool list_member_int(const List *list, int datum)
Definition: list.c:702
List * resultRelations
Definition: plannodes.h:106

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

◆ ExecRelGenVirtualNotNull()

AttrNumber ExecRelGenVirtualNotNull ( ResultRelInfo resultRelInfo,
TupleTableSlot slot,
EState estate,
List notnull_virtual_attrs 
)

Definition at line 2170 of file execMain.c.

2172{
2173 Relation rel = resultRelInfo->ri_RelationDesc;
2174 ExprContext *econtext;
2175 MemoryContext oldContext;
2176
2177 /*
2178 * We implement this by building a NullTest node for each virtual
2179 * generated column, which we cache in resultRelInfo, and running those
2180 * through ExecCheck().
2181 */
2182 if (resultRelInfo->ri_GenVirtualNotNullConstraintExprs == NULL)
2183 {
2184 oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
2186 palloc0_array(ExprState *, list_length(notnull_virtual_attrs));
2187
2188 foreach_int(attnum, notnull_virtual_attrs)
2189 {
2191 NullTest *nnulltest;
2192
2193 /* "generated_expression IS NOT NULL" check. */
2194 nnulltest = makeNode(NullTest);
2195 nnulltest->arg = (Expr *) build_generation_expression(rel, attnum);
2196 nnulltest->nulltesttype = IS_NOT_NULL;
2197 nnulltest->argisrow = false;
2198 nnulltest->location = -1;
2199
2200 resultRelInfo->ri_GenVirtualNotNullConstraintExprs[i] =
2201 ExecPrepareExpr((Expr *) nnulltest, estate);
2202 }
2203 MemoryContextSwitchTo(oldContext);
2204 }
2205
2206 /*
2207 * We will use the EState's per-tuple context for evaluating virtual
2208 * generated column not null constraint expressions (creating it if it's
2209 * not already there).
2210 */
2211 econtext = GetPerTupleExprContext(estate);
2212
2213 /* Arrange for econtext's scan tuple to be the tuple under test */
2214 econtext->ecxt_scantuple = slot;
2215
2216 /* And evaluate the check constraints for virtual generated column */
2217 foreach_int(attnum, notnull_virtual_attrs)
2218 {
2220 ExprState *exprstate = resultRelInfo->ri_GenVirtualNotNullConstraintExprs[i];
2221
2222 Assert(exprstate != NULL);
2223 if (!ExecCheck(exprstate, econtext))
2224 return attnum;
2225 }
2226
2227 /* InvalidAttrNumber result means no error */
2228 return InvalidAttrNumber;
2229}
#define palloc0_array(type, count)
Definition: fe_memutils.h:77
@ IS_NOT_NULL
Definition: primnodes.h:1957
Node * build_generation_expression(Relation rel, int attrno)
NullTestType nulltesttype
Definition: primnodes.h:1964
ParseLoc location
Definition: primnodes.h:1967
Expr * arg
Definition: primnodes.h:1963
ExprState ** ri_GenVirtualNotNullConstraintExprs
Definition: execnodes.h:556

References NullTest::arg, Assert(), attnum, build_generation_expression(), ExprContext::ecxt_scantuple, EState::es_query_cxt, ExecCheck(), ExecPrepareExpr(), foreach_current_index, foreach_int, GetPerTupleExprContext, i, InvalidAttrNumber, IS_NOT_NULL, list_length(), NullTest::location, makeNode, MemoryContextSwitchTo(), NullTest::nulltesttype, palloc0_array, ResultRelInfo::ri_GenVirtualNotNullConstraintExprs, and ResultRelInfo::ri_RelationDesc.

Referenced by ATRewriteTable(), and ExecConstraints().

◆ ExecReScan()

void ExecReScan ( PlanState node)

Definition at line 77 of file execAmi.c.

78{
79 /* If collecting timing stats, update them */
80 if (node->instrument)
82
83 /*
84 * If we have changed parameters, propagate that info.
85 *
86 * Note: ExecReScanSetParamPlan() can add bits to node->chgParam,
87 * corresponding to the output param(s) that the InitPlan will update.
88 * Since we make only one pass over the list, that means that an InitPlan
89 * can depend on the output param(s) of a sibling InitPlan only if that
90 * sibling appears earlier in the list. This is workable for now given
91 * the limited ways in which one InitPlan could depend on another, but
92 * eventually we might need to work harder (or else make the planner
93 * enlarge the extParam/allParam sets to include the params of depended-on
94 * InitPlans).
95 */
96 if (node->chgParam != NULL)
97 {
98 ListCell *l;
99
100 foreach(l, node->initPlan)
101 {
102 SubPlanState *sstate = (SubPlanState *) lfirst(l);
103 PlanState *splan = sstate->planstate;
104
105 if (splan->plan->extParam != NULL) /* don't care about child
106 * local Params */
108 if (splan->chgParam != NULL)
109 ExecReScanSetParamPlan(sstate, node);
110 }
111 foreach(l, node->subPlan)
112 {
113 SubPlanState *sstate = (SubPlanState *) lfirst(l);
114 PlanState *splan = sstate->planstate;
115
116 if (splan->plan->extParam != NULL)
118 }
119 /* Well. Now set chgParam for child trees. */
120 if (outerPlanState(node) != NULL)
122 if (innerPlanState(node) != NULL)
124 }
125
126 /* Call expression callbacks */
127 if (node->ps_ExprContext)
129
130 /* And do node-type-specific processing */
131 switch (nodeTag(node))
132 {
133 case T_ResultState:
135 break;
136
137 case T_ProjectSetState:
139 break;
140
141 case T_ModifyTableState:
143 break;
144
145 case T_AppendState:
147 break;
148
149 case T_MergeAppendState:
151 break;
152
153 case T_RecursiveUnionState:
155 break;
156
157 case T_BitmapAndState:
159 break;
160
161 case T_BitmapOrState:
163 break;
164
165 case T_SeqScanState:
167 break;
168
169 case T_SampleScanState:
171 break;
172
173 case T_GatherState:
175 break;
176
177 case T_GatherMergeState:
179 break;
180
181 case T_IndexScanState:
183 break;
184
185 case T_IndexOnlyScanState:
187 break;
188
189 case T_BitmapIndexScanState:
191 break;
192
193 case T_BitmapHeapScanState:
195 break;
196
197 case T_TidScanState:
199 break;
200
201 case T_TidRangeScanState:
203 break;
204
205 case T_SubqueryScanState:
207 break;
208
209 case T_FunctionScanState:
211 break;
212
213 case T_TableFuncScanState:
215 break;
216
217 case T_ValuesScanState:
219 break;
220
221 case T_CteScanState:
223 break;
224
225 case T_NamedTuplestoreScanState:
227 break;
228
229 case T_WorkTableScanState:
231 break;
232
233 case T_ForeignScanState:
235 break;
236
237 case T_CustomScanState:
239 break;
240
241 case T_NestLoopState:
243 break;
244
245 case T_MergeJoinState:
247 break;
248
249 case T_HashJoinState:
251 break;
252
253 case T_MaterialState:
255 break;
256
257 case T_MemoizeState:
259 break;
260
261 case T_SortState:
262 ExecReScanSort((SortState *) node);
263 break;
264
265 case T_IncrementalSortState:
267 break;
268
269 case T_GroupState:
270 ExecReScanGroup((GroupState *) node);
271 break;
272
273 case T_AggState:
274 ExecReScanAgg((AggState *) node);
275 break;
276
277 case T_WindowAggState:
279 break;
280
281 case T_UniqueState:
283 break;
284
285 case T_HashState:
286 ExecReScanHash((HashState *) node);
287 break;
288
289 case T_SetOpState:
290 ExecReScanSetOp((SetOpState *) node);
291 break;
292
293 case T_LockRowsState:
295 break;
296
297 case T_LimitState:
298 ExecReScanLimit((LimitState *) node);
299 break;
300
301 default:
302 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
303 break;
304 }
305
306 if (node->chgParam != NULL)
307 {
308 bms_free(node->chgParam);
309 node->chgParam = NULL;
310 }
311}
void ReScanExprContext(ExprContext *econtext)
Definition: execUtils.c:444
void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
Definition: execUtils.c:911
void InstrEndLoop(Instrumentation *instr)
Definition: instrument.c:140
void ExecReScanAgg(AggState *node)
Definition: nodeAgg.c:4466
void ExecReScanAppend(AppendState *node)
Definition: nodeAppend.c:421
void ExecReScanBitmapAnd(BitmapAndState *node)
void ExecReScanBitmapHeapScan(BitmapHeapScanState *node)
void ExecReScanBitmapIndexScan(BitmapIndexScanState *node)
void ExecReScanBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:219
void ExecReScanCteScan(CteScanState *node)
Definition: nodeCtescan.c:307
void ExecReScanCustomScan(CustomScanState *node)
Definition: nodeCustom.c:132
void ExecReScanForeignScan(ForeignScanState *node)
void ExecReScanFunctionScan(FunctionScanState *node)
void ExecReScanGatherMerge(GatherMergeState *node)
void ExecReScanGather(GatherState *node)
Definition: nodeGather.c:442
void ExecReScanGroup(GroupState *node)
Definition: nodeGroup.c:235
void ExecReScanHash(HashState *node)
Definition: nodeHash.c:2375
void ExecReScanHashJoin(HashJoinState *node)
void ExecReScanIncrementalSort(IncrementalSortState *node)
void ExecReScanIndexOnlyScan(IndexOnlyScanState *node)
void ExecReScanIndexScan(IndexScanState *node)
void ExecReScanLimit(LimitState *node)
Definition: nodeLimit.c:541
void ExecReScanLockRows(LockRowsState *node)
Definition: nodeLockRows.c:399
void ExecReScanMaterial(MaterialState *node)
Definition: nodeMaterial.c:313
void ExecReScanMemoize(MemoizeState *node)
Definition: nodeMemoize.c:1139
void ExecReScanMergeAppend(MergeAppendState *node)
void ExecReScanMergeJoin(MergeJoinState *node)
void ExecReScanModifyTable(ModifyTableState *node)
void ExecReScanNamedTuplestoreScan(NamedTuplestoreScanState *node)
void ExecReScanNestLoop(NestLoopState *node)
Definition: nodeNestloop.c:381
void ExecReScanProjectSet(ProjectSetState *node)
void ExecReScanRecursiveUnion(RecursiveUnionState *node)
void ExecReScanResult(ResultState *node)
Definition: nodeResult.c:249
void ExecReScanSampleScan(SampleScanState *node)
void ExecReScanSeqScan(SeqScanState *node)
Definition: nodeSeqscan.c:317
void ExecReScanSetOp(SetOpState *node)
Definition: nodeSetOp.c:693
void ExecReScanSort(SortState *node)
Definition: nodeSort.c:362
void ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent)
Definition: nodeSubplan.c:1299
void ExecReScanSubqueryScan(SubqueryScanState *node)
void ExecReScanTableFuncScan(TableFuncScanState *node)
void ExecReScanTidRangeScan(TidRangeScanState *node)
void ExecReScanTidScan(TidScanState *node)
Definition: nodeTidscan.c:447
void ExecReScanUnique(UniqueState *node)
Definition: nodeUnique.c:175
void ExecReScanValuesScan(ValuesScanState *node)
void ExecReScanWindowAgg(WindowAggState *node)
void ExecReScanWorkTableScan(WorkTableScanState *node)
static SPIPlanPtr splan
Definition: regress.c:271
List * subPlan
Definition: execnodes.h:1186
struct PlanState * planstate
Definition: execnodes.h:1006

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

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

◆ ExecRestrPos()

void ExecRestrPos ( PlanState node)

Definition at line 376 of file execAmi.c.

377{
378 switch (nodeTag(node))
379 {
380 case T_IndexScanState:
382 break;
383
384 case T_IndexOnlyScanState:
386 break;
387
388 case T_CustomScanState:
390 break;
391
392 case T_MaterialState:
394 break;
395
396 case T_SortState:
397 ExecSortRestrPos((SortState *) node);
398 break;
399
400 case T_ResultState:
402 break;
403
404 default:
405 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
406 break;
407 }
408}
void ExecCustomRestrPos(CustomScanState *node)
Definition: nodeCustom.c:150
void ExecIndexOnlyRestrPos(IndexOnlyScanState *node)
void ExecIndexRestrPos(IndexScanState *node)
void ExecMaterialRestrPos(MaterialState *node)
Definition: nodeMaterial.c:290
void ExecResultRestrPos(ResultState *node)
Definition: nodeResult.c:161
void ExecSortRestrPos(SortState *node)
Definition: nodeSort.c:347

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

Referenced by ExecMergeJoin(), and ExecResultRestrPos().

◆ ExecScan()

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

Definition at line 47 of file execScan.c.

50{
51 EPQState *epqstate;
52 ExprState *qual;
53 ProjectionInfo *projInfo;
54
55 epqstate = node->ps.state->es_epq_active;
56 qual = node->ps.qual;
57 projInfo = node->ps.ps_ProjInfo;
58
59 return ExecScanExtended(node,
60 accessMtd,
61 recheckMtd,
62 epqstate,
63 qual,
64 projInfo);
65}
static pg_attribute_always_inline TupleTableSlot * ExecScanExtended(ScanState *node, ExecScanAccessMtd accessMtd, ExecScanRecheckMtd recheckMtd, EPQState *epqstate, ExprState *qual, ProjectionInfo *projInfo)
Definition: execScan.h:152
struct EPQState * es_epq_active
Definition: execnodes.h:741
ExprState * qual
Definition: execnodes.h:1180

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

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

◆ ExecScanReScan()

void ExecScanReScan ( ScanState node)

Definition at line 108 of file execScan.c.

109{
110 EState *estate = node->ps.state;
111
112 /*
113 * We must clear the scan tuple so that observers (e.g., execCurrent.c)
114 * can tell that this plan node is not positioned on a tuple.
115 */
117
118 /*
119 * Rescan EvalPlanQual tuple(s) if we're inside an EvalPlanQual recheck.
120 * But don't lose the "blocked" status of blocked target relations.
121 */
122 if (estate->es_epq_active != NULL)
123 {
124 EPQState *epqstate = estate->es_epq_active;
125 Index scanrelid = ((Scan *) node->ps.plan)->scanrelid;
126
127 if (scanrelid > 0)
128 epqstate->relsubs_done[scanrelid - 1] =
129 epqstate->relsubs_blocked[scanrelid - 1];
130 else
131 {
132 Bitmapset *relids;
133 int rtindex = -1;
134
135 /*
136 * If an FDW or custom scan provider has replaced the join with a
137 * scan, there are multiple RTIs; reset the epqScanDone flag for
138 * all of them.
139 */
140 if (IsA(node->ps.plan, ForeignScan))
141 relids = ((ForeignScan *) node->ps.plan)->fs_base_relids;
142 else if (IsA(node->ps.plan, CustomScan))
143 relids = ((CustomScan *) node->ps.plan)->custom_relids;
144 else
145 elog(ERROR, "unexpected scan node: %d",
146 (int) nodeTag(node->ps.plan));
147
148 while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
149 {
150 Assert(rtindex > 0);
151 epqstate->relsubs_done[rtindex - 1] =
152 epqstate->relsubs_blocked[rtindex - 1];
153 }
154 }
155 }
156}
int bms_next_member(const Bitmapset *a, int prevbit)
Definition: bitmapset.c:1306

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

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

◆ ExecSetExecProcNode()

void ExecSetExecProcNode ( PlanState node,
ExecProcNodeMtd  function 
)

Definition at line 430 of file execProcnode.c.

431{
432 /*
433 * Add a wrapper around the ExecProcNode callback that checks stack depth
434 * during the first execution and maybe adds an instrumentation wrapper.
435 * When the callback is changed after execution has already begun that
436 * means we'll superfluously execute ExecProcNodeFirst, but that seems ok.
437 */
440}
static TupleTableSlot * ExecProcNodeFirst(PlanState *node)
Definition: execProcnode.c:448
on_exit_nicely_callback function
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:1166

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

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

◆ ExecSetTupleBound()

void ExecSetTupleBound ( int64  tuples_needed,
PlanState child_node 
)

Definition at line 848 of file execProcnode.c.

849{
850 /*
851 * Since this function recurses, in principle we should check stack depth
852 * here. In practice, it's probably pointless since the earlier node
853 * initialization tree traversal would surely have consumed more stack.
854 */
855
856 if (IsA(child_node, SortState))
857 {
858 /*
859 * If it is a Sort node, notify it that it can use bounded sort.
860 *
861 * Note: it is the responsibility of nodeSort.c to react properly to
862 * changes of these parameters. If we ever redesign this, it'd be a
863 * good idea to integrate this signaling with the parameter-change
864 * mechanism.
865 */
866 SortState *sortState = (SortState *) child_node;
867
868 if (tuples_needed < 0)
869 {
870 /* make sure flag gets reset if needed upon rescan */
871 sortState->bounded = false;
872 }
873 else
874 {
875 sortState->bounded = true;
876 sortState->bound = tuples_needed;
877 }
878 }
879 else if (IsA(child_node, IncrementalSortState))
880 {
881 /*
882 * If it is an IncrementalSort node, notify it that it can use bounded
883 * sort.
884 *
885 * Note: it is the responsibility of nodeIncrementalSort.c to react
886 * properly to changes of these parameters. If we ever redesign this,
887 * it'd be a good idea to integrate this signaling with the
888 * parameter-change mechanism.
889 */
890 IncrementalSortState *sortState = (IncrementalSortState *) child_node;
891
892 if (tuples_needed < 0)
893 {
894 /* make sure flag gets reset if needed upon rescan */
895 sortState->bounded = false;
896 }
897 else
898 {
899 sortState->bounded = true;
900 sortState->bound = tuples_needed;
901 }
902 }
903 else if (IsA(child_node, AppendState))
904 {
905 /*
906 * If it is an Append, we can apply the bound to any nodes that are
907 * children of the Append, since the Append surely need read no more
908 * than that many tuples from any one input.
909 */
910 AppendState *aState = (AppendState *) child_node;
911 int i;
912
913 for (i = 0; i < aState->as_nplans; i++)
914 ExecSetTupleBound(tuples_needed, aState->appendplans[i]);
915 }
916 else if (IsA(child_node, MergeAppendState))
917 {
918 /*
919 * If it is a MergeAppend, we can apply the bound to any nodes that
920 * are children of the MergeAppend, since the MergeAppend surely need
921 * read no more than that many tuples from any one input.
922 */
923 MergeAppendState *maState = (MergeAppendState *) child_node;
924 int i;
925
926 for (i = 0; i < maState->ms_nplans; i++)
927 ExecSetTupleBound(tuples_needed, maState->mergeplans[i]);
928 }
929 else if (IsA(child_node, ResultState))
930 {
931 /*
932 * Similarly, for a projecting Result, we can apply the bound to its
933 * child node.
934 *
935 * If Result supported qual checking, we'd have to punt on seeing a
936 * qual. Note that having a resconstantqual is not a showstopper: if
937 * that condition succeeds it affects nothing, while if it fails, no
938 * rows will be demanded from the Result child anyway.
939 */
940 if (outerPlanState(child_node))
941 ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
942 }
943 else if (IsA(child_node, SubqueryScanState))
944 {
945 /*
946 * We can also descend through SubqueryScan, but only if it has no
947 * qual (otherwise it might discard rows).
948 */
949 SubqueryScanState *subqueryState = (SubqueryScanState *) child_node;
950
951 if (subqueryState->ss.ps.qual == NULL)
952 ExecSetTupleBound(tuples_needed, subqueryState->subplan);
953 }
954 else if (IsA(child_node, GatherState))
955 {
956 /*
957 * A Gather node can propagate the bound to its workers. As with
958 * MergeAppend, no one worker could possibly need to return more
959 * tuples than the Gather itself needs to.
960 *
961 * Note: As with Sort, the Gather node is responsible for reacting
962 * properly to changes to this parameter.
963 */
964 GatherState *gstate = (GatherState *) child_node;
965
966 gstate->tuples_needed = tuples_needed;
967
968 /* Also pass down the bound to our own copy of the child plan */
969 ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
970 }
971 else if (IsA(child_node, GatherMergeState))
972 {
973 /* Same comments as for Gather */
974 GatherMergeState *gstate = (GatherMergeState *) child_node;
975
976 gstate->tuples_needed = tuples_needed;
977
978 ExecSetTupleBound(tuples_needed, outerPlanState(child_node));
979 }
980
981 /*
982 * In principle we could descend through any plan node type that is
983 * certain not to discard or combine input rows; but on seeing a node that
984 * can do that, we can't propagate the bound any further. For the moment
985 * it's unclear that any other cases are worth checking here.
986 */
987}
void ExecSetTupleBound(int64 tuples_needed, PlanState *child_node)
Definition: execProcnode.c:848
PlanState ** appendplans
Definition: execnodes.h:1491
int64 tuples_needed
Definition: execnodes.h:2739
PlanState ** mergeplans
Definition: execnodes.h:1535
bool bounded
Definition: execnodes.h:2398
int64 bound
Definition: execnodes.h:2399
PlanState * subplan
Definition: execnodes.h:1948

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

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

◆ ExecShouldLockRelations()

static bool ExecShouldLockRelations ( EState estate)
inlinestatic

Definition at line 322 of file executor.h.

323{
324 return estate->es_cachedplan == NULL ? false :
326}
return false
Definition: isn.c:135
static bool CachedPlanRequiresLocking(CachedPlan *cplan)
Definition: plancache.h:276

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

Referenced by ExecDoInitialPruning().

◆ ExecShutdownNode()

void ExecShutdownNode ( PlanState node)

Definition at line 772 of file execProcnode.c.

773{
774 (void) ExecShutdownNode_walker(node, NULL);
775}
static bool ExecShutdownNode_walker(PlanState *node, void *context)
Definition: execProcnode.c:778

References ExecShutdownNode_walker().

Referenced by ExecutePlan().

◆ ExecSimpleRelationDelete()

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

Definition at line 704 of file execReplication.c.

707{
708 bool skip_tuple = false;
709 Relation rel = resultRelInfo->ri_RelationDesc;
710 ItemPointer tid = &searchslot->tts_tid;
711
713
714 /* BEFORE ROW DELETE Triggers */
715 if (resultRelInfo->ri_TrigDesc &&
716 resultRelInfo->ri_TrigDesc->trig_delete_before_row)
717 {
718 skip_tuple = !ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
719 tid, NULL, NULL, NULL, NULL);
720 }
721
722 if (!skip_tuple)
723 {
724 /* OK, delete the tuple */
725 simple_table_tuple_delete(rel, tid, estate->es_snapshot);
726
727 /* AFTER ROW DELETE Triggers */
728 ExecARDeleteTriggers(estate, resultRelInfo,
729 tid, NULL, NULL, false);
730 }
731}
TriggerDesc * ri_TrigDesc
Definition: execnodes.h:510
bool trig_delete_before_row
Definition: reltrigger.h:66
void simple_table_tuple_delete(Relation rel, ItemPointer tid, Snapshot snapshot)
Definition: tableam.c:291
void ExecARDeleteTriggers(EState *estate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TransitionCaptureState *transition_capture, bool is_crosspart_update)
Definition: trigger.c:2781
bool ExecBRDeleteTriggers(EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot **epqslot, TM_Result *tmresult, TM_FailureData *tmfd)
Definition: trigger.c:2690

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

Referenced by apply_handle_delete_internal(), and apply_handle_tuple_routing().

◆ ExecSimpleRelationInsert()

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

Definition at line 532 of file execReplication.c.

534{
535 bool skip_tuple = false;
536 Relation rel = resultRelInfo->ri_RelationDesc;
537
538 /* For now we support only tables. */
539 Assert(rel->rd_rel->relkind == RELKIND_RELATION);
540
542
543 /* BEFORE ROW INSERT Triggers */
544 if (resultRelInfo->ri_TrigDesc &&
545 resultRelInfo->ri_TrigDesc->trig_insert_before_row)
546 {
547 if (!ExecBRInsertTriggers(estate, resultRelInfo, slot))
548 skip_tuple = true; /* "do nothing" */
549 }
550
551 if (!skip_tuple)
552 {
553 List *recheckIndexes = NIL;
554 List *conflictindexes;
555 bool conflict = false;
556
557 /* Compute stored generated columns */
558 if (rel->rd_att->constr &&
560 ExecComputeStoredGenerated(resultRelInfo, estate, slot,
561 CMD_INSERT);
562
563 /* Check the constraints of the tuple */
564 if (rel->rd_att->constr)
565 ExecConstraints(resultRelInfo, slot, estate);
566 if (rel->rd_rel->relispartition)
567 ExecPartitionCheck(resultRelInfo, slot, estate, true);
568
569 /* OK, store the tuple and create index entries for it */
570 simple_table_tuple_insert(resultRelInfo->ri_RelationDesc, slot);
571
572 conflictindexes = resultRelInfo->ri_onConflictArbiterIndexes;
573
574 if (resultRelInfo->ri_NumIndices > 0)
575 recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
576 slot, estate, false,
577 conflictindexes ? true : false,
578 &conflict,
579 conflictindexes, false);
580
581 /*
582 * Checks the conflict indexes to fetch the conflicting local tuple
583 * and reports the conflict. We perform this check here, instead of
584 * performing an additional index scan before the actual insertion and
585 * reporting the conflict if any conflicting tuples are found. This is
586 * to avoid the overhead of executing the extra scan for each INSERT
587 * operation, even when no conflict arises, which could introduce
588 * significant overhead to replication, particularly in cases where
589 * conflicts are rare.
590 *
591 * XXX OTOH, this could lead to clean-up effort for dead tuples added
592 * in heap and index in case of conflicts. But as conflicts shouldn't
593 * be a frequent thing so we preferred to save the performance
594 * overhead of extra scan before each insertion.
595 */
596 if (conflict)
597 CheckAndReportConflict(resultRelInfo, estate, CT_INSERT_EXISTS,
598 recheckIndexes, NULL, slot);
599
600 /* AFTER ROW INSERT Triggers */
601 ExecARInsertTriggers(estate, resultRelInfo, slot,
602 recheckIndexes, NULL);
603
604 /*
605 * XXX we should in theory pass a TransitionCaptureState object to the
606 * above to capture transition tuples, but after statement triggers
607 * don't actually get fired by replication yet anyway
608 */
609
610 list_free(recheckIndexes);
611 }
612}
@ CT_INSERT_EXISTS
Definition: conflict.h:27
List * ExecInsertIndexTuples(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool update, bool noDupErr, bool *specConflict, List *arbiterIndexes, bool onlySummarizing)
Definition: execIndexing.c:310
bool ExecPartitionCheck(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate, bool emitError)
Definition: execMain.c:1932
void ExecConstraints(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)
Definition: execMain.c:2056
static void CheckAndReportConflict(ResultRelInfo *resultRelInfo, EState *estate, ConflictType type, List *recheckIndexes, TupleTableSlot *searchslot, TupleTableSlot *remoteslot)
void ExecComputeStoredGenerated(ResultRelInfo *resultRelInfo, EState *estate, TupleTableSlot *slot, CmdType cmdtype)
TupleDesc rd_att
Definition: rel.h:112
List * ri_onConflictArbiterIndexes
Definition: execnodes.h:575
bool trig_insert_before_row
Definition: reltrigger.h:56
bool has_generated_stored
Definition: tupdesc.h:46
void simple_table_tuple_insert(Relation rel, TupleTableSlot *slot)
Definition: tableam.c:277
bool ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot)
Definition: trigger.c:2463
void ExecARInsertTriggers(EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot, List *recheckIndexes, TransitionCaptureState *transition_capture)
Definition: trigger.c:2541

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

Referenced by apply_handle_insert_internal().

◆ ExecSimpleRelationUpdate()

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

Definition at line 621 of file execReplication.c.

624{
625 bool skip_tuple = false;
626 Relation rel = resultRelInfo->ri_RelationDesc;
627 ItemPointer tid = &(searchslot->tts_tid);
628
629 /*
630 * We support only non-system tables, with
631 * check_publication_add_relation() accountable.
632 */
633 Assert(rel->rd_rel->relkind == RELKIND_RELATION);
635
637
638 /* BEFORE ROW UPDATE Triggers */
639 if (resultRelInfo->ri_TrigDesc &&
640 resultRelInfo->ri_TrigDesc->trig_update_before_row)
641 {
642 if (!ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
643 tid, NULL, slot, NULL, NULL))
644 skip_tuple = true; /* "do nothing" */
645 }
646
647 if (!skip_tuple)
648 {
649 List *recheckIndexes = NIL;
650 TU_UpdateIndexes update_indexes;
651 List *conflictindexes;
652 bool conflict = false;
653
654 /* Compute stored generated columns */
655 if (rel->rd_att->constr &&
657 ExecComputeStoredGenerated(resultRelInfo, estate, slot,
658 CMD_UPDATE);
659
660 /* Check the constraints of the tuple */
661 if (rel->rd_att->constr)
662 ExecConstraints(resultRelInfo, slot, estate);
663 if (rel->rd_rel->relispartition)
664 ExecPartitionCheck(resultRelInfo, slot, estate, true);
665
666 simple_table_tuple_update(rel, tid, slot, estate->es_snapshot,
667 &update_indexes);
668
669 conflictindexes = resultRelInfo->ri_onConflictArbiterIndexes;
670
671 if (resultRelInfo->ri_NumIndices > 0 && (update_indexes != TU_None))
672 recheckIndexes = ExecInsertIndexTuples(resultRelInfo,
673 slot, estate, true,
674 conflictindexes ? true : false,
675 &conflict, conflictindexes,
676 (update_indexes == TU_Summarizing));
677
678 /*
679 * Refer to the comments above the call to CheckAndReportConflict() in
680 * ExecSimpleRelationInsert to understand why this check is done at
681 * this point.
682 */
683 if (conflict)
684 CheckAndReportConflict(resultRelInfo, estate, CT_UPDATE_EXISTS,
685 recheckIndexes, searchslot, slot);
686
687 /* AFTER ROW UPDATE Triggers */
688 ExecARUpdateTriggers(estate, resultRelInfo,
689 NULL, NULL,
690 tid, NULL, slot,
691 recheckIndexes, NULL, false);
692
693 list_free(recheckIndexes);
694 }
695}
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:103
@ CT_UPDATE_EXISTS
Definition: conflict.h:33
bool trig_update_before_row
Definition: reltrigger.h:61
void simple_table_tuple_update(Relation rel, ItemPointer otid, TupleTableSlot *slot, Snapshot snapshot, TU_UpdateIndexes *update_indexes)
Definition: tableam.c:336
TU_UpdateIndexes
Definition: tableam.h:110
@ TU_Summarizing
Definition: tableam.h:118
@ TU_None
Definition: tableam.h:112
bool ExecBRUpdateTriggers(EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot *newslot, TM_Result *tmresult, TM_FailureData *tmfd)
Definition: trigger.c:2941
void ExecARUpdateTriggers(EState *estate, ResultRelInfo *relinfo, ResultRelInfo *src_partinfo, ResultRelInfo *dst_partinfo, ItemPointer tupleid, HeapTuple fdw_trigtuple, TupleTableSlot *newslot, List *recheckIndexes, TransitionCaptureState *transition_capture, bool is_crosspart_update)
Definition: trigger.c:3106

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

Referenced by apply_handle_tuple_routing(), and apply_handle_update_internal().

◆ ExecSupportsBackwardScan()

bool ExecSupportsBackwardScan ( Plan node)

Definition at line 511 of file execAmi.c.

512{
513 if (node == NULL)
514 return false;
515
516 /*
517 * Parallel-aware nodes return a subset of the tuples in each worker, and
518 * in general we can't expect to have enough bookkeeping state to know
519 * which ones we returned in this worker as opposed to some other worker.
520 */
521 if (node->parallel_aware)
522 return false;
523
524 switch (nodeTag(node))
525 {
526 case T_Result:
527 if (outerPlan(node) != NULL)
529 else
530 return false;
531
532 case T_Append:
533 {
534 ListCell *l;
535
536 /* With async, tuples may be interleaved, so can't back up. */
537 if (((Append *) node)->nasyncplans > 0)
538 return false;
539
540 foreach(l, ((Append *) node)->appendplans)
541 {
543 return false;
544 }
545 /* need not check tlist because Append doesn't evaluate it */
546 return true;
547 }
548
549 case T_SampleScan:
550 /* Simplify life for tablesample methods by disallowing this */
551 return false;
552
553 case T_Gather:
554 return false;
555
556 case T_IndexScan:
557 return IndexSupportsBackwardScan(((IndexScan *) node)->indexid);
558
559 case T_IndexOnlyScan:
560 return IndexSupportsBackwardScan(((IndexOnlyScan *) node)->indexid);
561
562 case T_SubqueryScan:
563 return ExecSupportsBackwardScan(((SubqueryScan *) node)->subplan);
564
565 case T_CustomScan:
566 if (((CustomScan *) node)->flags & CUSTOMPATH_SUPPORT_BACKWARD_SCAN)
567 return true;
568 return false;
569
570 case T_SeqScan:
571 case T_TidScan:
572 case T_TidRangeScan:
573 case T_FunctionScan:
574 case T_ValuesScan:
575 case T_CteScan:
576 case T_Material:
577 case T_Sort:
578 /* these don't evaluate tlist */
579 return true;
580
581 case T_IncrementalSort:
582
583 /*
584 * Unlike full sort, incremental sort keeps only a single group of
585 * tuples in memory, so it can't scan backwards.
586 */
587 return false;
588
589 case T_LockRows:
590 case T_Limit:
592
593 default:
594 return false;
595 }
596}
static bool IndexSupportsBackwardScan(Oid indexid)
Definition: execAmi.c:603
bool ExecSupportsBackwardScan(Plan *node)
Definition: execAmi.c:511
#define CUSTOMPATH_SUPPORT_BACKWARD_SCAN
Definition: extensible.h:84
bool parallel_aware
Definition: plannodes.h:193

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

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

◆ ExecSupportsMarkRestore()

bool ExecSupportsMarkRestore ( struct Path pathnode)

Definition at line 418 of file execAmi.c.

419{
420 /*
421 * For consistency with the routines above, we do not examine the nodeTag
422 * but rather the pathtype, which is the Plan node type the Path would
423 * produce.
424 */
425 switch (pathnode->pathtype)
426 {
427 case T_IndexScan:
428 case T_IndexOnlyScan:
429
430 /*
431 * Not all index types support mark/restore.
432 */
433 return castNode(IndexPath, pathnode)->indexinfo->amcanmarkpos;
434
435 case T_Material:
436 case T_Sort:
437 return true;
438
439 case T_CustomScan:
441 return true;
442 return false;
443
444 case T_Result:
445
446 /*
447 * Result supports mark/restore iff it has a child plan that does.
448 *
449 * We have to be careful here because there is more than one Path
450 * type that can produce a Result plan node.
451 */
452 if (IsA(pathnode, ProjectionPath))
453 return ExecSupportsMarkRestore(((ProjectionPath *) pathnode)->subpath);
454 else if (IsA(pathnode, MinMaxAggPath))
455 return false; /* childless Result */
456 else if (IsA(pathnode, GroupResultPath))
457 return false; /* childless Result */
458 else
459 {
460 /* Simple RTE_RESULT base relation */
461 Assert(IsA(pathnode, Path));
462 return false; /* childless Result */
463 }
464
465 case T_Append:
466 {
467 AppendPath *appendPath = castNode(AppendPath, pathnode);
468
469 /*
470 * If there's exactly one child, then there will be no Append
471 * in the final plan, so we can handle mark/restore if the
472 * child plan node can.
473 */
474 if (list_length(appendPath->subpaths) == 1)
475 return ExecSupportsMarkRestore((Path *) linitial(appendPath->subpaths));
476 /* Otherwise, Append can't handle it */
477 return false;
478 }
479
480 case T_MergeAppend:
481 {
482 MergeAppendPath *mapath = castNode(MergeAppendPath, pathnode);
483
484 /*
485 * Like the Append case above, single-subpath MergeAppends
486 * won't be in the final plan, so just return the child's
487 * mark/restore ability.
488 */
489 if (list_length(mapath->subpaths) == 1)
490 return ExecSupportsMarkRestore((Path *) linitial(mapath->subpaths));
491 /* Otherwise, MergeAppend can't handle it */
492 return false;
493 }
494
495 default:
496 break;
497 }
498
499 return false;
500}
bool ExecSupportsMarkRestore(Path *pathnode)
Definition: execAmi.c:418
#define CUSTOMPATH_SUPPORT_MARK_RESTORE
Definition: extensible.h:85
Datum subpath(PG_FUNCTION_ARGS)
Definition: ltree_op.c:311
#define castNode(_type_, nodeptr)
Definition: nodes.h:182
#define linitial(l)
Definition: pg_list.h:178
List * subpaths
Definition: pathnodes.h:1983
NodeTag pathtype
Definition: pathnodes.h:1676

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

Referenced by ExecSupportsMarkRestore(), and final_cost_mergejoin().

◆ ExecTargetListLength()

int ExecTargetListLength ( List targetlist)

Definition at line 1176 of file execUtils.c.

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

References list_length().

Referenced by ExecTypeFromTLInternal().

◆ execTuplesHashPrepare()

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

Definition at line 97 of file execGrouping.c.

101{
102 int i;
103
104 *eqFuncOids = (Oid *) palloc(numCols * sizeof(Oid));
105 *hashFunctions = (FmgrInfo *) palloc(numCols * sizeof(FmgrInfo));
106
107 for (i = 0; i < numCols; i++)
108 {
109 Oid eq_opr = eqOperators[i];
110 Oid eq_function;
111 Oid left_hash_function;
112 Oid right_hash_function;
113
114 eq_function = get_opcode(eq_opr);
115 if (!get_op_hash_functions(eq_opr,
116 &left_hash_function, &right_hash_function))
117 elog(ERROR, "could not find hash function for hash operator %u",
118 eq_opr);
119 /* We're not supporting cross-type cases here */
120 Assert(left_hash_function == right_hash_function);
121 (*eqFuncOids)[i] = eq_function;
122 fmgr_info(right_hash_function, &(*hashFunctions)[i]);
123 }
124}
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1425
bool get_op_hash_functions(Oid opno, RegProcedure *lhs_procno, RegProcedure *rhs_procno)
Definition: lsyscache.c:581

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

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

◆ execTuplesMatchPrepare()

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

Definition at line 58 of file execGrouping.c.

64{
65 Oid *eqFunctions;
66 int i;
67 ExprState *expr;
68
69 if (numCols == 0)
70 return NULL;
71
72 eqFunctions = (Oid *) palloc(numCols * sizeof(Oid));
73
74 /* lookup equality functions */
75 for (i = 0; i < numCols; i++)
76 eqFunctions[i] = get_opcode(eqOperators[i]);
77
78 /* build actual expression */
79 expr = ExecBuildGroupingEqual(desc, desc, NULL, NULL,
80 numCols, keyColIdx, eqFunctions, collations,
81 parent);
82
83 return expr;
84}

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

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

◆ ExecTypeFromExprList()

TupleDesc ExecTypeFromExprList ( List exprList)

Definition at line 2186 of file execTuples.c.

2187{
2188 TupleDesc typeInfo;
2189 ListCell *lc;
2190 int cur_resno = 1;
2191
2192 typeInfo = CreateTemplateTupleDesc(list_length(exprList));
2193
2194 foreach(lc, exprList)
2195 {
2196 Node *e = lfirst(lc);
2197
2198 TupleDescInitEntry(typeInfo,
2199 cur_resno,
2200 NULL,
2201 exprType(e),
2202 exprTypmod(e),
2203 0);
2205 cur_resno,
2206 exprCollation(e));
2207 cur_resno++;
2208 }
2209
2210 return typeInfo;
2211}
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
void TupleDescInitEntryCollation(TupleDesc desc, AttrNumber attributeNumber, Oid collationid)
Definition: tupdesc.c:1019

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

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

◆ ExecTypeFromTL()

◆ ExecTypeSetColNames()

void ExecTypeSetColNames ( TupleDesc  typeInfo,
List namesList 
)

Definition at line 2219 of file execTuples.c.

2220{
2221 int colno = 0;
2222 ListCell *lc;
2223
2224 /* It's only OK to change col names in a not-yet-blessed RECORD type */
2225 Assert(typeInfo->tdtypeid == RECORDOID);
2226 Assert(typeInfo->tdtypmod < 0);
2227
2228 foreach(lc, namesList)
2229 {
2230 char *cname = strVal(lfirst(lc));
2231 Form_pg_attribute attr;
2232
2233 /* Guard against too-long names list (probably can't happen) */
2234 if (colno >= typeInfo->natts)
2235 break;
2236 attr = TupleDescAttr(typeInfo, colno);
2237 colno++;
2238
2239 /*
2240 * Do nothing for empty aliases or dropped columns (these cases
2241 * probably can't arise in RECORD types, either)
2242 */
2243 if (cname[0] == '\0' || attr->attisdropped)
2244 continue;
2245
2246 /* OK, assign the column name */
2247 namestrcpy(&(attr->attname), cname);
2248 }
2249}
void namestrcpy(Name name, const char *str)
Definition: name.c:233
#define strVal(v)
Definition: value.h:82

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

Referenced by ExecEvalWholeRowVar(), and ExecInitExprRec().

◆ ExecUpdateLockMode()

LockTupleMode ExecUpdateLockMode ( EState estate,
ResultRelInfo relinfo 
)

Definition at line 2606 of file execMain.c.

2607{
2608 Bitmapset *keyCols;
2609 Bitmapset *updatedCols;
2610
2611 /*
2612 * Compute lock mode to use. If columns that are part of the key have not
2613 * been modified, then we can use a weaker lock, allowing for better
2614 * concurrency.
2615 */
2616 updatedCols = ExecGetAllUpdatedCols(relinfo, estate);
2619
2620 if (bms_overlap(keyCols, updatedCols))
2621 return LockTupleExclusive;
2622
2624}
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:582
Bitmapset * ExecGetAllUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1419
@ LockTupleExclusive
Definition: lockoptions.h:58
@ LockTupleNoKeyExclusive
Definition: lockoptions.h:56
Bitmapset * RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
Definition: relcache.c:5286
@ INDEX_ATTR_BITMAP_KEY
Definition: relcache.h:61

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

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

◆ executor_errposition()

int executor_errposition ( EState estate,
int  location 
)

Definition at line 937 of file execUtils.c.

938{
939 int pos;
940
941 /* No-op if location was not provided */
942 if (location < 0)
943 return 0;
944 /* Can't do anything if source text is not available */
945 if (estate == NULL || estate->es_sourceText == NULL)
946 return 0;
947 /* Convert offset to character number */
948 pos = pg_mbstrlen_with_len(estate->es_sourceText, location) + 1;
949 /* And pass it to the ereport mechanism */
950 return errposition(pos);
951}
int errposition(int cursorpos)
Definition: elog.c:1468
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:1057

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

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

◆ ExecutorEnd()

void ExecutorEnd ( QueryDesc queryDesc)

Definition at line 538 of file execMain.c.

539{
541 (*ExecutorEnd_hook) (queryDesc);
542 else
543 standard_ExecutorEnd(queryDesc);
544}
ExecutorEnd_hook_type ExecutorEnd_hook
Definition: execMain.c:73
void standard_ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:547

References ExecutorEnd_hook, and standard_ExecutorEnd().

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

◆ ExecutorFinish()

void ExecutorFinish ( QueryDesc queryDesc)

Definition at line 475 of file execMain.c.

476{
478 (*ExecutorFinish_hook) (queryDesc);
479 else
480 standard_ExecutorFinish(queryDesc);
481}
ExecutorFinish_hook_type ExecutorFinish_hook
Definition: execMain.c:72
void standard_ExecutorFinish(QueryDesc *queryDesc)
Definition: execMain.c:484

References ExecutorFinish_hook, and standard_ExecutorFinish().

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

◆ ExecutorRewind()

void ExecutorRewind ( QueryDesc queryDesc)

Definition at line 615 of file execMain.c.

616{
617 EState *estate;
618 MemoryContext oldcontext;
619
620 /* sanity checks */
621 Assert(queryDesc != NULL);
622
623 estate = queryDesc->estate;
624
625 Assert(estate != NULL);
626
627 /* It's probably not sensible to rescan updating queries */
628 Assert(queryDesc->operation == CMD_SELECT);
629
630 /*
631 * Switch into per-query memory context
632 */
633 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
634
635 /*
636 * rescan plan
637 */
638 ExecReScan(queryDesc->planstate);
639
640 MemoryContextSwitchTo(oldcontext);
641}
void ExecReScan(PlanState *node)
Definition: execAmi.c:77
CmdType operation
Definition: execdesc.h:36

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

Referenced by DoPortalRewind(), and PersistHoldablePortal().

◆ ExecutorRun()

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

Definition at line 365 of file execMain.c.

367{
369 (*ExecutorRun_hook) (queryDesc, direction, count);
370 else
371 standard_ExecutorRun(queryDesc, direction, count);
372}
ExecutorRun_hook_type ExecutorRun_hook
Definition: execMain.c:71
void standard_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count)
Definition: execMain.c:375

References ExecutorRun_hook, and standard_ExecutorRun().

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

◆ ExecutorStart()

bool ExecutorStart ( QueryDesc queryDesc,
int  eflags 
)

Definition at line 128 of file execMain.c.

129{
130 bool plan_valid;
131
132 /*
133 * In some cases (e.g. an EXECUTE statement or an execute message with the
134 * extended query protocol) the query_id won't be reported, so do it now.
135 *
136 * Note that it's harmless to report the query_id multiple times, as the
137 * call will be ignored if the top level query_id has already been
138 * reported.
139 */
140 pgstat_report_query_id(queryDesc->plannedstmt->queryId, false);
141
143 plan_valid = (*ExecutorStart_hook) (queryDesc, eflags);
144 else
145 plan_valid = standard_ExecutorStart(queryDesc, eflags);
146
147 return plan_valid;
148}
void pgstat_report_query_id(uint64 query_id, bool force)
ExecutorStart_hook_type ExecutorStart_hook
Definition: execMain.c:70
bool standard_ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:151
uint64 queryId
Definition: plannodes.h:56
PlannedStmt * plannedstmt
Definition: execdesc.h:37

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

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

◆ ExecutorStartCachedPlan()

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

Definition at line 295 of file execMain.c.

298{
299 if (unlikely(queryDesc->cplan == NULL))
300 elog(ERROR, "ExecutorStartCachedPlan(): missing CachedPlan");
301 if (unlikely(plansource == NULL))
302 elog(ERROR, "ExecutorStartCachedPlan(): missing CachedPlanSource");
303
304 /*
305 * Loop and retry with an updated plan until no further invalidation
306 * occurs.
307 */
308 while (1)
309 {
310 if (!ExecutorStart(queryDesc, eflags))
311 {
312 /*
313 * Clean up the current execution state before creating the new
314 * plan to retry ExecutorStart(). Mark execution as aborted to
315 * ensure that AFTER trigger state is properly reset.
316 */
317 queryDesc->estate->es_aborted = true;
318 ExecutorEnd(queryDesc);
319
320 /* Retry ExecutorStart() with an updated plan tree. */
321 queryDesc->plannedstmt = UpdateCachedPlan(plansource, query_index,
322 queryDesc->queryEnv);
323 }
324 else
325
326 /*
327 * Exit the loop if the plan is initialized successfully and no
328 * sinval messages were received that invalidated the CachedPlan.
329 */
330 break;
331 }
332}
#define unlikely(x)
Definition: c.h:347
bool ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:128
void ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:538
PlannedStmt * UpdateCachedPlan(CachedPlanSource *plansource, int query_index, QueryEnvironment *queryEnv)
Definition: plancache.c:1205
CachedPlan * cplan
Definition: execdesc.h:38
QueryEnvironment * queryEnv
Definition: execdesc.h:44

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

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

◆ ExecWithCheckOptions()

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

Definition at line 2304 of file execMain.c.

2306{
2307 Relation rel = resultRelInfo->ri_RelationDesc;
2308 TupleDesc tupdesc = RelationGetDescr(rel);
2309 ExprContext *econtext;
2310 ListCell *l1,
2311 *l2;
2312
2313 /*
2314 * We will use the EState's per-tuple context for evaluating constraint
2315 * expressions (creating it if it's not already there).
2316 */
2317 econtext = GetPerTupleExprContext(estate);
2318
2319 /* Arrange for econtext's scan tuple to be the tuple under test */
2320 econtext->ecxt_scantuple = slot;
2321
2322 /* Check each of the constraints */
2323 forboth(l1, resultRelInfo->ri_WithCheckOptions,
2324 l2, resultRelInfo->ri_WithCheckOptionExprs)
2325 {
2326 WithCheckOption *wco = (WithCheckOption *) lfirst(l1);
2327 ExprState *wcoExpr = (ExprState *) lfirst(l2);
2328
2329 /*
2330 * Skip any WCOs which are not the kind we are looking for at this
2331 * time.
2332 */
2333 if (wco->kind != kind)
2334 continue;
2335
2336 /*
2337 * WITH CHECK OPTION checks are intended to ensure that the new tuple
2338 * is visible (in the case of a view) or that it passes the
2339 * 'with-check' policy (in the case of row security). If the qual
2340 * evaluates to NULL or FALSE, then the new tuple won't be included in
2341 * the view or doesn't pass the 'with-check' policy for the table.
2342 */
2343 if (!ExecQual(wcoExpr, econtext))
2344 {
2345 char *val_desc;
2346 Bitmapset *modifiedCols;
2347
2348 switch (wco->kind)
2349 {
2350 /*
2351 * For WITH CHECK OPTIONs coming from views, we might be
2352 * able to provide the details on the row, depending on
2353 * the permissions on the relation (that is, if the user
2354 * could view it directly anyway). For RLS violations, we
2355 * don't include the data since we don't know if the user
2356 * should be able to view the tuple as that depends on the
2357 * USING policy.
2358 */
2359 case WCO_VIEW_CHECK:
2360 /* See the comment in ExecConstraints(). */
2361 if (resultRelInfo->ri_RootResultRelInfo)
2362 {
2363 ResultRelInfo *rootrel = resultRelInfo->ri_RootResultRelInfo;
2364 TupleDesc old_tupdesc = RelationGetDescr(rel);
2365 AttrMap *map;
2366
2367 tupdesc = RelationGetDescr(rootrel->ri_RelationDesc);
2368 /* a reverse map */
2369 map = build_attrmap_by_name_if_req(old_tupdesc,
2370 tupdesc,
2371 false);
2372
2373 /*
2374 * Partition-specific slot's tupdesc can't be changed,
2375 * so allocate a new one.
2376 */
2377 if (map != NULL)
2378 slot = execute_attr_map_slot(map, slot,
2380
2381 modifiedCols = bms_union(ExecGetInsertedCols(rootrel, estate),
2382 ExecGetUpdatedCols(rootrel, estate));
2383 rel = rootrel->ri_RelationDesc;
2384 }
2385 else
2386 modifiedCols = bms_union(ExecGetInsertedCols(resultRelInfo, estate),
2387 ExecGetUpdatedCols(resultRelInfo, estate));
2389 slot,
2390 tupdesc,
2391 modifiedCols,
2392 64);
2393
2394 ereport(ERROR,
2395 (errcode(ERRCODE_WITH_CHECK_OPTION_VIOLATION),
2396 errmsg("new row violates check option for view \"%s\"",
2397 wco->relname),
2398 val_desc ? errdetail("Failing row contains %s.",
2399 val_desc) : 0));
2400 break;
2403 if (wco->polname != NULL)
2404 ereport(ERROR,
2405 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2406 errmsg("new row violates row-level security policy \"%s\" for table \"%s\"",
2407 wco->polname, wco->relname)));
2408 else
2409 ereport(ERROR,
2410 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2411 errmsg("new row violates row-level security policy for table \"%s\"",
2412 wco->relname)));
2413 break;
2416 if (wco->polname != NULL)
2417 ereport(ERROR,
2418 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2419 errmsg("target row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
2420 wco->polname, wco->relname)));
2421 else
2422 ereport(ERROR,
2423 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2424 errmsg("target row violates row-level security policy (USING expression) for table \"%s\"",
2425 wco->relname)));
2426 break;
2428 if (wco->polname != NULL)
2429 ereport(ERROR,
2430 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2431 errmsg("new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
2432 wco->polname, wco->relname)));
2433 else
2434 ereport(ERROR,
2435 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
2436 errmsg("new row violates row-level security policy (USING expression) for table \"%s\"",
2437 wco->relname)));
2438 break;
2439 default:
2440 elog(ERROR, "unrecognized WCO kind: %u", wco->kind);
2441 break;
2442 }
2443 }
2444 }
2445}
@ WCO_RLS_MERGE_UPDATE_CHECK
Definition: parsenodes.h:1377
@ WCO_RLS_CONFLICT_CHECK
Definition: parsenodes.h:1376
@ WCO_RLS_INSERT_CHECK
Definition: parsenodes.h:1374
@ WCO_VIEW_CHECK
Definition: parsenodes.h:1373
@ WCO_RLS_UPDATE_CHECK
Definition: parsenodes.h:1375
@ WCO_RLS_MERGE_DELETE_CHECK
Definition: parsenodes.h:1378
List * ri_WithCheckOptions
Definition: execnodes.h:544
List * ri_WithCheckOptionExprs
Definition: execnodes.h:547

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

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

◆ FindTupleHashEntry()

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

Definition at line 382 of file execGrouping.c.

385{
386 TupleHashEntry entry;
387 MemoryContext oldContext;
389
390 /* Need to run the hash functions in short-lived context */
391 oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
392
393 /* Set up data needed by hash and match functions */
394 hashtable->inputslot = slot;
395 hashtable->in_hash_expr = hashexpr;
396 hashtable->cur_eq_func = eqcomp;
397
398 /* Search the hash table */
399 key = NULL; /* flag to reference inputslot */
400 entry = tuplehash_lookup(hashtable->hashtab, key);
401 MemoryContextSwitchTo(oldContext);
402
403 return entry;
404}

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

Referenced by ExecHashSubPlan().

◆ FreeExecutorState()

void FreeExecutorState ( EState estate)

Definition at line 193 of file execUtils.c.

194{
195 /*
196 * Shut down and free any remaining ExprContexts. We do this explicitly
197 * to ensure that any remaining shutdown callbacks get called (since they
198 * might need to release resources that aren't simply memory within the
199 * per-query memory context).
200 */
201 while (estate->es_exprcontexts)
202 {
203 /*
204 * XXX: seems there ought to be a faster way to implement this than
205 * repeated list_delete(), no?
206 */
208 true);
209 /* FreeExprContext removed the list link for us */
210 }
211
212 /* release JIT context, if allocated */
213 if (estate->es_jit)
214 {
216 estate->es_jit = NULL;
217 }
218
219 /* release partition directory, if allocated */
220 if (estate->es_partition_directory)
221 {
223 estate->es_partition_directory = NULL;
224 }
225
226 /*
227 * Free the per-query memory context, thereby releasing all working
228 * memory, including the EState node itself.
229 */
231}
void FreeExprContext(ExprContext *econtext, bool isCommit)
Definition: execUtils.c:417
void jit_release_context(JitContext *context)
Definition: jit.c:137
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
void DestroyPartitionDirectory(PartitionDirectory pdir)
Definition: partdesc.c:484
PartitionDirectory es_partition_directory
Definition: execnodes.h:690

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

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

◆ FreeExprContext()

void FreeExprContext ( ExprContext econtext,
bool  isCommit 
)

Definition at line 417 of file execUtils.c.

418{
419 EState *estate;
420
421 /* Call any registered callbacks */
422 ShutdownExprContext(econtext, isCommit);
423 /* And clean up the memory used */
425 /* Unlink self from owning EState, if any */
426 estate = econtext->ecxt_estate;
427 if (estate)
429 econtext);
430 /* And delete the ExprContext node */
431 pfree(econtext);
432}
static void ShutdownExprContext(ExprContext *econtext, bool isCommit)
Definition: execUtils.c:1021
List * list_delete_ptr(List *list, void *datum)
Definition: list.c:872

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

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

◆ GetAttributeByName()

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

Definition at line 1062 of file execUtils.c.

1063{
1064 AttrNumber attrno;
1065 Datum result;
1066 Oid tupType;
1067 int32 tupTypmod;
1068 TupleDesc tupDesc;
1069 HeapTupleData tmptup;
1070 int i;
1071
1072 if (attname == NULL)
1073 elog(ERROR, "invalid attribute name");
1074
1075 if (isNull == NULL)
1076 elog(ERROR, "a NULL isNull pointer was passed");
1077
1078 if (tuple == NULL)
1079 {
1080 /* Kinda bogus but compatible with old behavior... */
1081 *isNull = true;
1082 return (Datum) 0;
1083 }
1084
1085 tupType = HeapTupleHeaderGetTypeId(tuple);
1086 tupTypmod = HeapTupleHeaderGetTypMod(tuple);
1087 tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1088
1089 attrno = InvalidAttrNumber;
1090 for (i = 0; i < tupDesc->natts; i++)
1091 {
1092 Form_pg_attribute att = TupleDescAttr(tupDesc, i);
1093
1094 if (namestrcmp(&(att->attname), attname) == 0)
1095 {
1096 attrno = att->attnum;
1097 break;
1098 }
1099 }
1100
1101 if (attrno == InvalidAttrNumber)
1102 elog(ERROR, "attribute \"%s\" does not exist", attname);
1103
1104 /*
1105 * heap_getattr needs a HeapTuple not a bare HeapTupleHeader. We set all
1106 * the fields in the struct just in case user tries to inspect system
1107 * columns.
1108 */
1109 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
1110 ItemPointerSetInvalid(&(tmptup.t_self));
1111 tmptup.t_tableOid = InvalidOid;
1112 tmptup.t_data = tuple;
1113
1114 result = heap_getattr(&tmptup,
1115 attrno,
1116 tupDesc,
1117 isNull);
1118
1119 ReleaseTupleDesc(tupDesc);
1120
1121 return result;
1122}
int32_t int32
Definition: c.h:498
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:904
int namestrcmp(Name name, const char *str)
Definition: name.c:247
NameData attname
Definition: pg_attribute.h:41
ItemPointerData t_self
Definition: htup.h:65
Oid t_tableOid
Definition: htup.h:66
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:219
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition: typcache.c:1922

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

Referenced by c_overpaid(), and overpaid().

◆ GetAttributeByNum()

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

Definition at line 1125 of file execUtils.c.

1128{
1129 Datum result;
1130 Oid tupType;
1131 int32 tupTypmod;
1132 TupleDesc tupDesc;
1133 HeapTupleData tmptup;
1134
1135 if (!AttributeNumberIsValid(attrno))
1136 elog(ERROR, "invalid attribute number %d", attrno);
1137
1138 if (isNull == NULL)
1139 elog(ERROR, "a NULL isNull pointer was passed");
1140
1141 if (tuple == NULL)
1142 {
1143 /* Kinda bogus but compatible with old behavior... */
1144 *isNull = true;
1145 return (Datum) 0;
1146 }
1147
1148 tupType = HeapTupleHeaderGetTypeId(tuple);
1149 tupTypmod = HeapTupleHeaderGetTypMod(tuple);
1150 tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1151
1152 /*
1153 * heap_getattr needs a HeapTuple not a bare HeapTupleHeader. We set all
1154 * the fields in the struct just in case user tries to inspect system
1155 * columns.
1156 */
1157 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
1158 ItemPointerSetInvalid(&(tmptup.t_self));
1159 tmptup.t_tableOid = InvalidOid;
1160 tmptup.t_data = tuple;
1161
1162 result = heap_getattr(&tmptup,
1163 attrno,
1164 tupDesc,
1165 isNull);
1166
1167 ReleaseTupleDesc(tupDesc);
1168
1169 return result;
1170}

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

◆ InitResultRelInfo()

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

Definition at line 1329 of file execMain.c.

1334{
1335 MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
1336 resultRelInfo->type = T_ResultRelInfo;
1337 resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
1338 resultRelInfo->ri_RelationDesc = resultRelationDesc;
1339 resultRelInfo->ri_NumIndices = 0;
1340 resultRelInfo->ri_IndexRelationDescs = NULL;
1341 resultRelInfo->ri_IndexRelationInfo = NULL;
1342 resultRelInfo->ri_needLockTagTuple =
1343 IsInplaceUpdateRelation(resultRelationDesc);
1344 /* make a copy so as not to depend on relcache info not changing... */
1345 resultRelInfo->ri_TrigDesc = CopyTriggerDesc(resultRelationDesc->trigdesc);
1346 if (resultRelInfo->ri_TrigDesc)
1347 {
1348 int n = resultRelInfo->ri_TrigDesc->numtriggers;
1349
1350 resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
1351 palloc0(n * sizeof(FmgrInfo));
1352 resultRelInfo->ri_TrigWhenExprs = (ExprState **)
1353 palloc0(n * sizeof(ExprState *));
1354 if (instrument_options)
1355 resultRelInfo->ri_TrigInstrument = InstrAlloc(n, instrument_options, false);
1356 }
1357 else
1358 {
1359 resultRelInfo->ri_TrigFunctions = NULL;
1360 resultRelInfo->ri_TrigWhenExprs = NULL;
1361 resultRelInfo->ri_TrigInstrument = NULL;
1362 }
1363 if (resultRelationDesc->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
1364 resultRelInfo->ri_FdwRoutine = GetFdwRoutineForRelation(resultRelationDesc, true);
1365 else
1366 resultRelInfo->ri_FdwRoutine = NULL;
1367
1368 /* The following fields are set later if needed */
1369 resultRelInfo->ri_RowIdAttNo = 0;
1370 resultRelInfo->ri_extraUpdatedCols = NULL;
1371 resultRelInfo->ri_projectNew = NULL;
1372 resultRelInfo->ri_newTupleSlot = NULL;
1373 resultRelInfo->ri_oldTupleSlot = NULL;
1374 resultRelInfo->ri_projectNewInfoValid = false;
1375 resultRelInfo->ri_FdwState = NULL;
1376 resultRelInfo->ri_usesFdwDirectModify = false;
1377 resultRelInfo->ri_CheckConstraintExprs = NULL;
1378 resultRelInfo->ri_GenVirtualNotNullConstraintExprs = NULL;
1379 resultRelInfo->ri_GeneratedExprsI = NULL;
1380 resultRelInfo->ri_GeneratedExprsU = NULL;
1381 resultRelInfo->ri_projectReturning = NULL;
1382 resultRelInfo->ri_onConflictArbiterIndexes = NIL;
1383 resultRelInfo->ri_onConflict = NULL;
1384 resultRelInfo->ri_ReturningSlot = NULL;
1385 resultRelInfo->ri_TrigOldSlot = NULL;
1386 resultRelInfo->ri_TrigNewSlot = NULL;
1387 resultRelInfo->ri_AllNullSlot = NULL;
1388 resultRelInfo->ri_MergeActions[MERGE_WHEN_MATCHED] = NIL;
1391 resultRelInfo->ri_MergeJoinCondition = NULL;
1392
1393 /*
1394 * Only ExecInitPartitionInfo() and ExecInitPartitionDispatchInfo() pass
1395 * non-NULL partition_root_rri. For child relations that are part of the
1396 * initial query rather than being dynamically added by tuple routing,
1397 * this field is filled in ExecInitModifyTable().
1398 */
1399 resultRelInfo->ri_RootResultRelInfo = partition_root_rri;
1400 /* Set by ExecGetRootToChildMap */
1401 resultRelInfo->ri_RootToChildMap = NULL;
1402 resultRelInfo->ri_RootToChildMapValid = false;
1403 /* Set by ExecInitRoutingInfo */
1404 resultRelInfo->ri_PartitionTupleSlot = NULL;
1405 resultRelInfo->ri_ChildToRootMap = NULL;
1406 resultRelInfo->ri_ChildToRootMapValid = false;
1407 resultRelInfo->ri_CopyMultiInsertBuffer = NULL;
1408}
#define MemSet(start, val, len)
Definition: c.h:991
@ MERGE_WHEN_NOT_MATCHED_BY_TARGET
Definition: primnodes.h:2003
@ MERGE_WHEN_NOT_MATCHED_BY_SOURCE
Definition: primnodes.h:2002
@ MERGE_WHEN_MATCHED
Definition: primnodes.h:2001
TriggerDesc * trigdesc
Definition: rel.h:117
ExprState ** ri_CheckConstraintExprs
Definition: execnodes.h:550
TupleTableSlot * ri_PartitionTupleSlot
Definition: execnodes.h:616
OnConflictSetState * ri_onConflict
Definition: execnodes.h:578
Instrumentation * ri_TrigInstrument
Definition: execnodes.h:519
ExprState * ri_MergeJoinCondition
Definition: execnodes.h:584
TupleTableSlot * ri_oldTupleSlot
Definition: execnodes.h:502
struct CopyMultiInsertBuffer * ri_CopyMultiInsertBuffer
Definition: execnodes.h:619
ExprState ** ri_GeneratedExprsI
Definition: execnodes.h:561
void * ri_FdwState
Definition: execnodes.h:531
List * ri_MergeActions[NUM_MERGE_MATCH_KINDS]
Definition: execnodes.h:581
TupleTableSlot * ri_newTupleSlot
Definition: execnodes.h:500
NodeTag type
Definition: execnodes.h:469
ProjectionInfo * ri_projectReturning
Definition: execnodes.h:572
ExprState ** ri_GeneratedExprsU
Definition: execnodes.h:562
ExprState ** ri_TrigWhenExprs
Definition: execnodes.h:516
FmgrInfo * ri_TrigFunctions
Definition: execnodes.h:513
bool ri_usesFdwDirectModify
Definition: execnodes.h:534
AttrNumber ri_RowIdAttNo
Definition: execnodes.h:490
int numtriggers
Definition: reltrigger.h:50
TriggerDesc * CopyTriggerDesc(TriggerDesc *trigdesc)
Definition: trigger.c:2090

References CopyTriggerDesc(), GetFdwRoutineForRelation(), InstrAlloc(), IsInplaceUpdateRelation(), MemSet, MERGE_WHEN_MATCHED, MERGE_WHEN_NOT_MATCHED_BY_SOURCE, MERGE_WHEN_NOT_MATCHED_BY_TARGET, NIL, TriggerDesc::numtriggers, palloc0(), RelationData::rd_rel, ResultRelInfo::ri_AllNullSlot, ResultRelInfo::ri_CheckConstraintExprs, ResultRelInfo::ri_ChildToRootMap, ResultRelInfo::ri_ChildToRootMapValid, ResultRelInfo::ri_CopyMultiInsertBuffer, ResultRelInfo::ri_extraUpdatedCols, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_FdwState, ResultRelInfo::ri_GeneratedExprsI, ResultRelInfo::ri_GeneratedExprsU, ResultRelInfo::ri_GenVirtualNotNullConstraintExprs, ResultRelInfo::ri_IndexRelationDescs, ResultRelInfo::ri_IndexRelationInfo, ResultRelInfo::ri_MergeActions, ResultRelInfo::ri_MergeJoinCondition, ResultRelInfo::ri_needLockTagTuple, ResultRelInfo::ri_newTupleSlot, ResultRelInfo::ri_NumIndices, ResultRelInfo::ri_oldTupleSlot, ResultRelInfo::ri_onConflict, ResultRelInfo::ri_onConflictArbiterIndexes, ResultRelInfo::ri_PartitionTupleSlot, ResultRelInfo::ri_projectNew, ResultRelInfo::ri_projectNewInfoValid, ResultRelInfo::ri_projectReturning, ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_ReturningSlot, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_RootToChildMap, ResultRelInfo::ri_RootToChildMapValid, ResultRelInfo::ri_RowIdAttNo, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_TrigFunctions, ResultRelInfo::ri_TrigInstrument, ResultRelInfo::ri_TrigNewSlot, ResultRelInfo::ri_TrigOldSlot, ResultRelInfo::ri_TrigWhenExprs, ResultRelInfo::ri_usesFdwDirectModify, RelationData::trigdesc, and ResultRelInfo::type.

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

◆ LookupTupleHashEntry()

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

Definition at line 295 of file execGrouping.c.

297{
298 TupleHashEntry entry;
299 MemoryContext oldContext;
300 uint32 local_hash;
301
302 /* Need to run the hash functions in short-lived context */
303 oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
304
305 /* set up data needed by hash and match functions */
306 hashtable->inputslot = slot;
307 hashtable->in_hash_expr = hashtable->tab_hash_expr;
308 hashtable->cur_eq_func = hashtable->tab_eq_func;
309
310 local_hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
311 entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, local_hash);
312
313 if (hash != NULL)
314 *hash = local_hash;
315
316 Assert(entry == NULL || entry->hash == local_hash);
317
318 MemoryContextSwitchTo(oldContext);
319
320 return entry;
321}
static uint32 TupleHashTableHash_internal(struct tuplehash_hash *tb, const MinimalTuple tuple)
Definition: execGrouping.c:415
static TupleHashEntry LookupTupleHashEntry_internal(TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew, uint32 hash)
Definition: execGrouping.c:463
static unsigned hash(unsigned *uv, int n)
Definition: rege_dfa.c:715

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

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

◆ LookupTupleHashEntryHash()

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

Definition at line 350 of file execGrouping.c.

352{
353 TupleHashEntry entry;
354 MemoryContext oldContext;
355
356 /* Need to run the hash functions in short-lived context */
357 oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
358
359 /* set up data needed by hash and match functions */
360 hashtable->inputslot = slot;
361 hashtable->in_hash_expr = hashtable->tab_hash_expr;
362 hashtable->cur_eq_func = hashtable->tab_eq_func;
363
364 entry = LookupTupleHashEntry_internal(hashtable, slot, isnew, hash);
365 Assert(entry == NULL || entry->hash == hash);
366
367 MemoryContextSwitchTo(oldContext);
368
369 return entry;
370}

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

Referenced by agg_refill_hash_table().

◆ MakePerTupleExprContext()

ExprContext * MakePerTupleExprContext ( EState estate)

Definition at line 459 of file execUtils.c.

460{
461 if (estate->es_per_tuple_exprcontext == NULL)
463
464 return estate->es_per_tuple_exprcontext;
465}

References CreateExprContext(), and EState::es_per_tuple_exprcontext.

◆ MultiExecProcNode()

Node * MultiExecProcNode ( PlanState node)

Definition at line 507 of file execProcnode.c.

508{
509 Node *result;
510
512
514
515 if (node->chgParam != NULL) /* something changed */
516 ExecReScan(node); /* let ReScan handle this */
517
518 switch (nodeTag(node))
519 {
520 /*
521 * Only node types that actually support multiexec will be listed
522 */
523
524 case T_HashState:
525 result = MultiExecHash((HashState *) node);
526 break;
527
528 case T_BitmapIndexScanState:
530 break;
531
532 case T_BitmapAndState:
533 result = MultiExecBitmapAnd((BitmapAndState *) node);
534 break;
535
536 case T_BitmapOrState:
537 result = MultiExecBitmapOr((BitmapOrState *) node);
538 break;
539
540 default:
541 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
542 result = NULL;
543 break;
544 }
545
546 return result;
547}
Node * MultiExecBitmapAnd(BitmapAndState *node)
Node * MultiExecBitmapIndexScan(BitmapIndexScanState *node)
Node * MultiExecBitmapOr(BitmapOrState *node)
Definition: nodeBitmapOr.c:111
Node * MultiExecHash(HashState *node)
Definition: nodeHash.c:105

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

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

◆ RegisterExprContextCallback()

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

Definition at line 964 of file execUtils.c.

967{
968 ExprContext_CB *ecxt_callback;
969
970 /* Save the info in appropriate memory context */
971 ecxt_callback = (ExprContext_CB *)
973 sizeof(ExprContext_CB));
974
975 ecxt_callback->function = function;
976 ecxt_callback->arg = arg;
977
978 /* link to front of list for appropriate execution order */
979 ecxt_callback->next = econtext->ecxt_callbacks;
980 econtext->ecxt_callbacks = ecxt_callback;
981}
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
void * arg
struct ExprContext_CB * next
Definition: execnodes.h:234
ExprContextCallbackFunction function
Definition: execnodes.h:235

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

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

◆ RelationFindReplTupleByIndex()

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

Definition at line 179 of file execReplication.c.

183{
185 int skey_attoff;
186 IndexScanDesc scan;
187 SnapshotData snap;
188 TransactionId xwait;
189 Relation idxrel;
190 bool found;
191 TypeCacheEntry **eq = NULL;
192 bool isIdxSafeToSkipDuplicates;
193
194 /* Open the index. */
195 idxrel = index_open(idxoid, RowExclusiveLock);
196
197 isIdxSafeToSkipDuplicates = (GetRelationIdentityOrPK(rel) == idxoid);
198
199 InitDirtySnapshot(snap);
200
201 /* Build scan key. */
202 skey_attoff = build_replindex_scan_key(skey, rel, idxrel, searchslot);
203
204 /* Start an index scan. */
205 scan = index_beginscan(rel, idxrel, &snap, NULL, skey_attoff, 0);
206
207retry:
208 found = false;
209
210 index_rescan(scan, skey, skey_attoff, NULL, 0);
211
212 /* Try to find the tuple */
213 while (index_getnext_slot(scan, ForwardScanDirection, outslot))
214 {
215 /*
216 * Avoid expensive equality check if the index is primary key or
217 * replica identity index.
218 */
219 if (!isIdxSafeToSkipDuplicates)
220 {
221 if (eq == NULL)
222 eq = palloc0(sizeof(*eq) * outslot->tts_tupleDescriptor->natts);
223
224 if (!tuples_equal(outslot, searchslot, eq))
225 continue;
226 }
227
228 ExecMaterializeSlot(outslot);
229
230 xwait = TransactionIdIsValid(snap.xmin) ?
231 snap.xmin : snap.xmax;
232
233 /*
234 * If the tuple is locked, wait for locking transaction to finish and
235 * retry.
236 */
237 if (TransactionIdIsValid(xwait))
238 {
239 XactLockTableWait(xwait, NULL, NULL, XLTW_None);
240 goto retry;
241 }
242
243 /* Found our tuple and it's not locked */
244 found = true;
245 break;
246 }
247
248 /* Found tuple, try to lock it in the lockmode. */
249 if (found)
250 {
251 TM_FailureData tmfd;
252 TM_Result res;
253
255
256 res = table_tuple_lock(rel, &(outslot->tts_tid), GetActiveSnapshot(),
257 outslot,
258 GetCurrentCommandId(false),
259 lockmode,
261 0 /* don't follow updates */ ,
262 &tmfd);
263
265
266 if (should_refetch_tuple(res, &tmfd))
267 goto retry;
268 }
269
270 index_endscan(scan);
271
272 /* Don't release lock until commit. */
273 index_close(idxrel, NoLock);
274
275 return found;
276}
uint32 TransactionId
Definition: c.h:623
static bool tuples_equal(TupleTableSlot *slot1, TupleTableSlot *slot2, TypeCacheEntry **eq)
static bool should_refetch_tuple(TM_Result res, TM_FailureData *tmfd)
static int build_replindex_scan_key(ScanKey skey, Relation rel, Relation idxrel, TupleTableSlot *searchslot)
bool index_getnext_slot(IndexScanDesc scan, ScanDirection direction, TupleTableSlot *slot)
Definition: indexam.c:720
IndexScanDesc index_beginscan(Relation heapRelation, Relation indexRelation, Snapshot snapshot, IndexScanInstrumentation *instrument, int nkeys, int norderbys)
Definition: indexam.c:256
void index_endscan(IndexScanDesc scan)
Definition: indexam.c:382
void index_rescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int norderbys)
Definition: indexam.c:356
void XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid, XLTW_Oper oper)
Definition: lmgr.c:663
@ XLTW_None
Definition: lmgr.h:26
@ LockWaitBlock
Definition: lockoptions.h:39
Snapshot GetLatestSnapshot(void)
Definition: snapmgr.c:342
void PushActiveSnapshot(Snapshot snapshot)
Definition: snapmgr.c:669
void PopActiveSnapshot(void)
Definition: snapmgr.c:762
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:787
#define InitDirtySnapshot(snapshotdata)
Definition: snapmgr.h:42
Oid GetRelationIdentityOrPK(Relation rel)
Definition: relation.c:891
TransactionId xmin
Definition: snapshot.h:153
TransactionId xmax
Definition: snapshot.h:154
TM_Result
Definition: tableam.h:72
static TM_Result table_tuple_lock(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd)
Definition: tableam.h:1540
#define TransactionIdIsValid(xid)
Definition: transam.h:41
CommandId GetCurrentCommandId(bool used)
Definition: xact.c:829

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

Referenced by FindReplTupleInLocalRel().

◆ RelationFindReplTupleSeq()

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

Definition at line 355 of file execReplication.c.

357{
358 TupleTableSlot *scanslot;
359 TableScanDesc scan;
360 SnapshotData snap;
361 TypeCacheEntry **eq;
362 TransactionId xwait;
363 bool found;
365
367
368 eq = palloc0(sizeof(*eq) * outslot->tts_tupleDescriptor->natts);
369
370 /* Start a heap scan. */
371 InitDirtySnapshot(snap);
372 scan = table_beginscan(rel, &snap, 0, NULL);
373 scanslot = table_slot_create(rel, NULL);
374
375retry:
376 found = false;
377
378 table_rescan(scan, NULL);
379
380 /* Try to find the tuple */
381 while (table_scan_getnextslot(scan, ForwardScanDirection, scanslot))
382 {
383 if (!tuples_equal(scanslot, searchslot, eq))
384 continue;
385
386 found = true;
387 ExecCopySlot(outslot, scanslot);
388
389 xwait = TransactionIdIsValid(snap.xmin) ?
390 snap.xmin : snap.xmax;
391
392 /*
393 * If the tuple is locked, wait for locking transaction to finish and
394 * retry.
395 */
396 if (TransactionIdIsValid(xwait))
397 {
398 XactLockTableWait(xwait, NULL, NULL, XLTW_None);
399 goto retry;
400 }
401
402 /* Found our tuple and it's not locked */
403 break;
404 }
405
406 /* Found tuple, try to lock it in the lockmode. */
407 if (found)
408 {
409 TM_FailureData tmfd;
410 TM_Result res;
411
413
414 res = table_tuple_lock(rel, &(outslot->tts_tid), GetActiveSnapshot(),
415 outslot,
416 GetCurrentCommandId(false),
417 lockmode,
419 0 /* don't follow updates */ ,
420 &tmfd);
421
423
424 if (should_refetch_tuple(res, &tmfd))
425 goto retry;
426 }
427
428 table_endscan(scan);
430
431 return found;
432}
static TableScanDesc table_beginscan(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key)
Definition: tableam.h:870
static void table_endscan(TableScanDesc scan)
Definition: tableam.h:979
static void table_rescan(TableScanDesc scan, struct ScanKeyData *key)
Definition: tableam.h:988
static bool table_scan_getnextslot(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
Definition: tableam.h:1015
bool equalTupleDescs(TupleDesc tupdesc1, TupleDesc tupdesc2)
Definition: tupdesc.c:583

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

Referenced by FindReplTupleInLocalRel().

◆ ReScanExprContext()

void ReScanExprContext ( ExprContext econtext)

Definition at line 444 of file execUtils.c.

445{
446 /* Call any registered callbacks */
447 ShutdownExprContext(econtext, true);
448 /* And clean up the memory used */
450}

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

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

◆ ResetTupleHashTable()

void ResetTupleHashTable ( TupleHashTable  hashtable)

Definition at line 274 of file execGrouping.c.

275{
276 tuplehash_reset(hashtable->hashtab);
277}

References TupleHashTableData::hashtab.

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

◆ standard_ExecutorEnd()

void standard_ExecutorEnd ( QueryDesc queryDesc)

Definition at line 547 of file execMain.c.

548{
549 EState *estate;
550 MemoryContext oldcontext;
551
552 /* sanity checks */
553 Assert(queryDesc != NULL);
554
555 estate = queryDesc->estate;
556
557 Assert(estate != NULL);
558
559 if (estate->es_parallel_workers_to_launch > 0)
562
563 /*
564 * Check that ExecutorFinish was called, unless in EXPLAIN-only mode or if
565 * execution was aborted.
566 */
567 Assert(estate->es_finished || estate->es_aborted ||
569
570 /*
571 * Switch into per-query memory context to run ExecEndPlan
572 */
573 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
574
575 ExecEndPlan(queryDesc->planstate, estate);
576
577 /* do away with our snapshots */
580
581 /*
582 * Reset AFTER trigger module if the query execution was aborted.
583 */
584 if (estate->es_aborted &&
585 !(estate->es_top_eflags &
588
589 /*
590 * Must switch out of context before destroying it
591 */
592 MemoryContextSwitchTo(oldcontext);
593
594 /*
595 * Release EState and per-query memory context. This should release
596 * everything the executor has allocated.
597 */
598 FreeExecutorState(estate);
599
600 /* Reset queryDesc fields that no longer point to anything */
601 queryDesc->tupDesc = NULL;
602 queryDesc->estate = NULL;
603 queryDesc->planstate = NULL;
604 queryDesc->totaltime = NULL;
605}
static void ExecEndPlan(PlanState *planstate, EState *estate)
Definition: execMain.c:1612
#define EXEC_FLAG_SKIP_TRIGGERS
Definition: executor.h:71
int64 PgStat_Counter
Definition: pgstat.h:65
void pgstat_update_parallel_workers_stats(PgStat_Counter workers_to_launch, PgStat_Counter workers_launched)
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:853
struct Instrumentation * totaltime
Definition: execdesc.h:56
TupleDesc tupDesc
Definition: execdesc.h:48
void AfterTriggerAbortQuery(void)
Definition: trigger.c:5068

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

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

◆ standard_ExecutorFinish()

void standard_ExecutorFinish ( QueryDesc queryDesc)

Definition at line 484 of file execMain.c.

485{
486 EState *estate;
487 MemoryContext oldcontext;
488
489 /* sanity checks */
490 Assert(queryDesc != NULL);
491
492 estate = queryDesc->estate;
493
494 Assert(estate != NULL);
496
497 /*
498 * This should be run once and only once per Executor instance and never
499 * if the execution was aborted.
500 */
501 Assert(!estate->es_finished && !estate->es_aborted);
502
503 /* Switch into per-query memory context */
504 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
505
506 /* Allow instrumentation of Executor overall runtime */
507 if (queryDesc->totaltime)
508 InstrStartNode(queryDesc->totaltime);
509
510 /* Run ModifyTable nodes to completion */
511 ExecPostprocessPlan(estate);
512
513 /* Execute queued AFTER triggers, unless told not to */
514 if (!(estate->es_top_eflags & EXEC_FLAG_SKIP_TRIGGERS))
515 AfterTriggerEndQuery(estate);
516
517 if (queryDesc->totaltime)
518 InstrStopNode(queryDesc->totaltime, 0);
519
520 MemoryContextSwitchTo(oldcontext);
521
522 estate->es_finished = true;
523}
static void ExecPostprocessPlan(EState *estate)
Definition: execMain.c:1566
void InstrStartNode(Instrumentation *instr)
Definition: instrument.c:68
void InstrStopNode(Instrumentation *instr, double nTuples)
Definition: instrument.c:84
void AfterTriggerEndQuery(EState *estate)
Definition: trigger.c:5088

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

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

◆ standard_ExecutorRun()

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

Definition at line 375 of file execMain.c.

377{
378 EState *estate;
379 CmdType operation;
381 bool sendTuples;
382 MemoryContext oldcontext;
383
384 /* sanity checks */
385 Assert(queryDesc != NULL);
386
387 estate = queryDesc->estate;
388
389 Assert(estate != NULL);
390 Assert(!estate->es_aborted);
392
393 /* caller must ensure the query's snapshot is active */
395
396 /*
397 * Switch into per-query memory context
398 */
399 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
400
401 /* Allow instrumentation of Executor overall runtime */
402 if (queryDesc->totaltime)
403 InstrStartNode(queryDesc->totaltime);
404
405 /*
406 * extract information from the query descriptor and the query feature.
407 */
408 operation = queryDesc->operation;
409 dest = queryDesc->dest;
410
411 /*
412 * startup tuple receiver, if we will be emitting tuples
413 */
414 estate->es_processed = 0;
415
416 sendTuples = (operation == CMD_SELECT ||
417 queryDesc->plannedstmt->hasReturning);
418
419 if (sendTuples)
420 dest->rStartup(dest, operation, queryDesc->tupDesc);
421
422 /*
423 * Run plan, unless direction is NoMovement.
424 *
425 * Note: pquery.c selects NoMovement if a prior call already reached
426 * end-of-data in the user-specified fetch direction. This is important
427 * because various parts of the executor can misbehave if called again
428 * after reporting EOF. For example, heapam.c would actually restart a
429 * heapscan and return all its data afresh. There is also some doubt
430 * about whether a parallel plan would operate properly if an additional,
431 * necessarily non-parallel execution request occurs after completing a
432 * parallel execution. (That case should work, but it's untested.)
433 */
434 if (!ScanDirectionIsNoMovement(direction))
435 ExecutePlan(queryDesc,
436 operation,
437 sendTuples,
438 count,
439 direction,
440 dest);
441
442 /*
443 * Update es_total_processed to keep track of the number of tuples
444 * processed across multiple ExecutorRun() calls.
445 */
446 estate->es_total_processed += estate->es_processed;
447
448 /*
449 * shutdown tuple receiver, if we started it
450 */
451 if (sendTuples)
452 dest->rShutdown(dest);
453
454 if (queryDesc->totaltime)
455 InstrStopNode(queryDesc->totaltime, estate->es_processed);
456
457 MemoryContextSwitchTo(oldcontext);
458}
static void ExecutePlan(QueryDesc *queryDesc, CmdType operation, bool sendTuples, uint64 numberTuples, ScanDirection direction, DestReceiver *dest)
Definition: execMain.c:1732
CmdType
Definition: nodes.h:269
#define ScanDirectionIsNoMovement(direction)
Definition: sdir.h:57
bool hasReturning
Definition: plannodes.h:62
DestReceiver * dest
Definition: execdesc.h:42

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

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

◆ standard_ExecutorStart()

bool standard_ExecutorStart ( QueryDesc queryDesc,
int  eflags 
)

Definition at line 151 of file execMain.c.

152{
153 EState *estate;
154 MemoryContext oldcontext;
155
156 /* sanity checks: queryDesc must not be started already */
157 Assert(queryDesc != NULL);
158 Assert(queryDesc->estate == NULL);
159
160 /* caller must ensure the query's snapshot is active */
161 Assert(GetActiveSnapshot() == queryDesc->snapshot);
162
163 /*
164 * If the transaction is read-only, we need to check if any writes are
165 * planned to non-temporary tables. EXPLAIN is considered read-only.
166 *
167 * Don't allow writes in parallel mode. Supporting UPDATE and DELETE
168 * would require (a) storing the combo CID hash in shared memory, rather
169 * than synchronizing it just once at the start of parallelism, and (b) an
170 * alternative to heap_update()'s reliance on xmax for mutual exclusion.
171 * INSERT may have no such troubles, but we forbid it to simplify the
172 * checks.
173 *
174 * We have lower-level defenses in CommandCounterIncrement and elsewhere
175 * against performing unsafe operations in parallel mode, but this gives a
176 * more user-friendly error message.
177 */
178 if ((XactReadOnly || IsInParallelMode()) &&
179 !(eflags & EXEC_FLAG_EXPLAIN_ONLY))
181
182 /*
183 * Build EState, switch into per-query memory context for startup.
184 */
185 estate = CreateExecutorState();
186 queryDesc->estate = estate;
187
188 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
189
190 /*
191 * Fill in external parameters, if any, from queryDesc; and allocate
192 * workspace for internal parameters
193 */
194 estate->es_param_list_info = queryDesc->params;
195
196 if (queryDesc->plannedstmt->paramExecTypes != NIL)
197 {
198 int nParamExec;
199
200 nParamExec = list_length(queryDesc->plannedstmt->paramExecTypes);
202 palloc0(nParamExec * sizeof(ParamExecData));
203 }
204
205 /* We now require all callers to provide sourceText */
206 Assert(queryDesc->sourceText != NULL);
207 estate->es_sourceText = queryDesc->sourceText;
208
209 /*
210 * Fill in the query environment, if any, from queryDesc.
211 */
212 estate->es_queryEnv = queryDesc->queryEnv;
213
214 /*
215 * If non-read-only query, set the command ID to mark output tuples with
216 */
217 switch (queryDesc->operation)
218 {
219 case CMD_SELECT:
220
221 /*
222 * SELECT FOR [KEY] UPDATE/SHARE and modifying CTEs need to mark
223 * tuples
224 */
225 if (queryDesc->plannedstmt->rowMarks != NIL ||
226 queryDesc->plannedstmt->hasModifyingCTE)
227 estate->es_output_cid = GetCurrentCommandId(true);
228
229 /*
230 * A SELECT without modifying CTEs can't possibly queue triggers,
231 * so force skip-triggers mode. This is just a marginal efficiency
232 * hack, since AfterTriggerBeginQuery/AfterTriggerEndQuery aren't
233 * all that expensive, but we might as well do it.
234 */
235 if (!queryDesc->plannedstmt->hasModifyingCTE)
236 eflags |= EXEC_FLAG_SKIP_TRIGGERS;
237 break;
238
239 case CMD_INSERT:
240 case CMD_DELETE:
241 case CMD_UPDATE:
242 case CMD_MERGE:
243 estate->es_output_cid = GetCurrentCommandId(true);
244 break;
245
246 default:
247 elog(ERROR, "unrecognized operation code: %d",
248 (int) queryDesc->operation);
249 break;
250 }
251
252 /*
253 * Copy other important information into the EState
254 */
255 estate->es_snapshot = RegisterSnapshot(queryDesc->snapshot);
257 estate->es_top_eflags = eflags;
258 estate->es_instrument = queryDesc->instrument_options;
259 estate->es_jit_flags = queryDesc->plannedstmt->jitFlags;
260
261 /*
262 * Set up an AFTER-trigger statement context, unless told not to, or
263 * unless it's EXPLAIN-only mode (when ExecutorFinish won't be called).
264 */
267
268 /*
269 * Initialize the plan state tree
270 */
271 InitPlan(queryDesc, eflags);
272
273 MemoryContextSwitchTo(oldcontext);
274
275 return ExecPlanStillValid(queryDesc->estate);
276}
static void ExecCheckXactReadOnly(PlannedStmt *plannedstmt)
Definition: execMain.c:896
static void InitPlan(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:936
EState * CreateExecutorState(void)
Definition: execUtils.c:88
static bool ExecPlanStillValid(EState *estate)
Definition: executor.h:311
@ CMD_MERGE
Definition: nodes.h:275
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:811
bool hasModifyingCTE
Definition: plannodes.h:65
List * rowMarks
Definition: plannodes.h:127
int jitFlags
Definition: plannodes.h:80
const char * sourceText
Definition: execdesc.h:39
ParamListInfo params
Definition: execdesc.h:43
int instrument_options
Definition: execdesc.h:45
Snapshot snapshot
Definition: execdesc.h:40
Snapshot crosscheck_snapshot
Definition: execdesc.h:41
void AfterTriggerBeginQuery(void)
Definition: trigger.c:5053
bool XactReadOnly
Definition: xact.c:82
bool IsInParallelMode(void)
Definition: xact.c:1089

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

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

◆ TupleHashEntryGetAdditional()

static void * TupleHashEntryGetAdditional ( TupleHashTable  hashtable,
TupleHashEntry  entry 
)
inlinestatic

Definition at line 189 of file executor.h.

190{
191 if (hashtable->additionalsize > 0)
192 return (char *) entry->firstTuple - hashtable->additionalsize;
193 else
194 return NULL;
195}
MinimalTuple firstTuple
Definition: execnodes.h:848

References TupleHashTableData::additionalsize, and TupleHashEntryData::firstTuple.

Referenced by agg_refill_hash_table(), agg_retrieve_hash_table_in_memory(), initialize_hash_entry(), lookup_hash_entries(), setop_fill_hash_table(), and setop_retrieve_hash_table().

◆ TupleHashEntryGetTuple()

static MinimalTuple TupleHashEntryGetTuple ( TupleHashEntry  entry)
inlinestatic

Definition at line 175 of file executor.h.

176{
177 return entry->firstTuple;
178}

References TupleHashEntryData::firstTuple.

Referenced by agg_retrieve_hash_table_in_memory(), findPartialMatch(), and setop_retrieve_hash_table().

◆ TupleHashEntrySize()

static size_t TupleHashEntrySize ( void  )
inlinestatic

Definition at line 166 of file executor.h.

167{
168 return sizeof(TupleHashEntryData);
169}

Referenced by build_hash_tables(), hash_agg_entry_size(), and hash_agg_update_metrics().

◆ TupleHashTableHash()

uint32 TupleHashTableHash ( TupleHashTable  hashtable,
TupleTableSlot slot 
)

Definition at line 327 of file execGrouping.c.

328{
329 MemoryContext oldContext;
330 uint32 hash;
331
332 hashtable->inputslot = slot;
333 hashtable->in_hash_expr = hashtable->tab_hash_expr;
334
335 /* Need to run the hash functions in short-lived context */
336 oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
337
338 hash = TupleHashTableHash_internal(hashtable->hashtab, NULL);
339
340 MemoryContextSwitchTo(oldContext);
341
342 return hash;
343}

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

◆ UnregisterExprContextCallback()

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

Definition at line 990 of file execUtils.c.

993{
994 ExprContext_CB **prev_callback;
995 ExprContext_CB *ecxt_callback;
996
997 prev_callback = &econtext->ecxt_callbacks;
998
999 while ((ecxt_callback = *prev_callback) != NULL)
1000 {
1001 if (ecxt_callback->function == function && ecxt_callback->arg == arg)
1002 {
1003 *prev_callback = ecxt_callback->next;
1004 pfree(ecxt_callback);
1005 }
1006 else
1007 prev_callback = &ecxt_callback->next;
1008 }
1009}

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

Referenced by end_MultiFuncCall(), and fmgr_sql().

◆ UpdateChangedParamSet()

void UpdateChangedParamSet ( PlanState node,
Bitmapset newchg 
)

Definition at line 911 of file execUtils.c.

912{
913 Bitmapset *parmset;
914
915 /*
916 * The plan node only depends on params listed in its allParam set. Don't
917 * include anything else into its chgParam set.
918 */
919 parmset = bms_intersect(node->plan->allParam, newchg);
920 node->chgParam = bms_join(node->chgParam, parmset);
921}
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:292
Bitmapset * bms_join(Bitmapset *a, Bitmapset *b)
Definition: bitmapset.c:1230
Bitmapset * allParam
Definition: plannodes.h:230

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

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

Variable Documentation

◆ ExecutorCheckPerms_hook

PGDLLIMPORT ExecutorCheckPerms_hook_type ExecutorCheckPerms_hook
extern

Definition at line 76 of file execMain.c.

Referenced by _PG_init(), and ExecCheckPermissions().

◆ ExecutorEnd_hook

PGDLLIMPORT ExecutorEnd_hook_type ExecutorEnd_hook
extern

Definition at line 73 of file execMain.c.

Referenced by _PG_init(), and ExecutorEnd().

◆ ExecutorFinish_hook

PGDLLIMPORT ExecutorFinish_hook_type ExecutorFinish_hook
extern

Definition at line 72 of file execMain.c.

Referenced by _PG_init(), and ExecutorFinish().

◆ ExecutorRun_hook

PGDLLIMPORT ExecutorRun_hook_type ExecutorRun_hook
extern

Definition at line 71 of file execMain.c.

Referenced by _PG_init(), and ExecutorRun().

◆ ExecutorStart_hook

PGDLLIMPORT ExecutorStart_hook_type ExecutorStart_hook
extern

Definition at line 70 of file execMain.c.

Referenced by _PG_init(), and ExecutorStart().