PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
execUtils.c File Reference
#include "postgres.h"
#include "access/parallel.h"
#include "access/table.h"
#include "access/tableam.h"
#include "executor/executor.h"
#include "executor/nodeModifyTable.h"
#include "jit/jit.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "parser/parse_relation.h"
#include "partitioning/partdesc.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/typcache.h"
Include dependency graph for execUtils.c:

Go to the source code of this file.

Functions

static bool tlist_matches_tupdesc (PlanState *ps, List *tlist, int varno, TupleDesc tupdesc)
 
static void ShutdownExprContext (ExprContext *econtext, bool isCommit)
 
static RTEPermissionInfoGetResultRTEPermissionInfo (ResultRelInfo *relinfo, EState *estate)
 
EStateCreateExecutorState (void)
 
void FreeExecutorState (EState *estate)
 
static ExprContextCreateExprContextInternal (EState *estate, Size minContextSize, Size initBlockSize, Size maxBlockSize)
 
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)
 
Relation ExecGetRangeTableRelation (EState *estate, Index rti)
 
void ExecInitResultRelation (EState *estate, ResultRelInfo *resultRelInfo, Index rti)
 
void UpdateChangedParamSet (PlanState *node, Bitmapset *newchg)
 
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)
 
TupleConversionMapExecGetChildToRootMap (ResultRelInfo *resultRelInfo)
 
TupleConversionMapExecGetRootToChildMap (ResultRelInfo *resultRelInfo, EState *estate)
 
BitmapsetExecGetInsertedCols (ResultRelInfo *relinfo, EState *estate)
 
BitmapsetExecGetUpdatedCols (ResultRelInfo *relinfo, EState *estate)
 
BitmapsetExecGetExtraUpdatedCols (ResultRelInfo *relinfo, EState *estate)
 
BitmapsetExecGetAllUpdatedCols (ResultRelInfo *relinfo, EState *estate)
 
Oid ExecGetResultRelCheckAsUser (ResultRelInfo *relInfo, EState *estate)
 

Function Documentation

◆ 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
122 estate->es_junkFilter = NULL;
123
124 estate->es_output_cid = (CommandId) 0;
125
126 estate->es_result_relations = NULL;
130
133
134 estate->es_param_list_info = NULL;
135 estate->es_param_exec_vals = NULL;
136
137 estate->es_queryEnv = NULL;
138
139 estate->es_query_cxt = qcontext;
140
141 estate->es_tupleTable = NIL;
142
143 estate->es_processed = 0;
144 estate->es_total_processed = 0;
145
146 estate->es_top_eflags = 0;
147 estate->es_instrument = 0;
148 estate->es_finished = false;
149
150 estate->es_exprcontexts = NIL;
151
152 estate->es_subplanstates = NIL;
153
154 estate->es_auxmodifytables = NIL;
155
156 estate->es_per_tuple_exprcontext = NULL;
157
158 estate->es_sourceText = NULL;
159
160 estate->es_use_parallel_mode = false;
163
164 estate->es_jit_flags = 0;
165 estate->es_jit = NULL;
166
167 /*
168 * Return the executor state structure
169 */
170 MemoryContextSwitchTo(oldcontext);
171
172 return estate;
173}
uint32 CommandId
Definition: c.h:620
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:155
#define NIL
Definition: pg_list.h:68
MemoryContextSwitchTo(old_ctx)
@ ForwardScanDirection
Definition: sdir.h:28
#define InvalidSnapshot
Definition: snapshot.h:119
uint64 es_processed
Definition: execnodes.h:679
struct ExecRowMark ** es_rowmarks
Definition: execnodes.h:638
int es_parallel_workers_to_launch
Definition: execnodes.h:711
List * es_tuple_routing_result_relations
Definition: execnodes.h:663
int es_top_eflags
Definition: execnodes.h:684
struct JitContext * es_jit
Definition: execnodes.h:729
int es_instrument
Definition: execnodes.h:685
PlannedStmt * es_plannedstmt
Definition: execnodes.h:641
QueryEnvironment * es_queryEnv
Definition: execnodes.h:672
ResultRelInfo ** es_result_relations
Definition: execnodes.h:650
ParamExecData * es_param_exec_vals
Definition: execnodes.h:670
uint64 es_total_processed
Definition: execnodes.h:681
List * es_range_table
Definition: execnodes.h:634
List * es_rteperminfos
Definition: execnodes.h:640
List * es_exprcontexts
Definition: execnodes.h:688
ParamListInfo es_param_list_info
Definition: execnodes.h:669
bool es_finished
Definition: execnodes.h:686
List * es_insert_pending_result_relations
Definition: execnodes.h:736
MemoryContext es_query_cxt
Definition: execnodes.h:675
List * es_tupleTable
Definition: execnodes.h:677
ScanDirection es_direction
Definition: execnodes.h:631
List * es_trig_target_relations
Definition: execnodes.h:666
int es_jit_flags
Definition: execnodes.h:728
List * es_opened_result_relations
Definition: execnodes.h:653
bool es_use_parallel_mode
Definition: execnodes.h:709
Relation * es_relations
Definition: execnodes.h:636
List * es_subplanstates
Definition: execnodes.h:690
ExprContext * es_per_tuple_exprcontext
Definition: execnodes.h:699
int es_parallel_workers_launched
Definition: execnodes.h:713
CommandId es_output_cid
Definition: execnodes.h:647
Index es_range_table_size
Definition: execnodes.h:635
List * es_insert_pending_modifytables
Definition: execnodes.h:737
const char * es_sourceText
Definition: execnodes.h:642
Snapshot es_snapshot
Definition: execnodes.h:632
List * es_auxmodifytables
Definition: execnodes.h:692
JunkFilter * es_junkFilter
Definition: execnodes.h:644
Snapshot es_crosscheck_snapshot
Definition: execnodes.h:633

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

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

◆ CreateExprContext()

ExprContext * CreateExprContext ( EState estate)

Definition at line 306 of file execUtils.c.

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

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

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

◆ CreateExprContextInternal()

static ExprContext * CreateExprContextInternal ( EState estate,
Size  minContextSize,
Size  initBlockSize,
Size  maxBlockSize 
)
static

Definition at line 236 of file execUtils.c.

238{
239 ExprContext *econtext;
240 MemoryContext oldcontext;
241
242 /* Create the ExprContext node within the per-query memory context */
243 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
244
245 econtext = makeNode(ExprContext);
246
247 /* Initialize fields of ExprContext */
248 econtext->ecxt_scantuple = NULL;
249 econtext->ecxt_innertuple = NULL;
250 econtext->ecxt_outertuple = NULL;
251
252 econtext->ecxt_per_query_memory = estate->es_query_cxt;
253
254 /*
255 * Create working memory for expression evaluation in this context.
256 */
257 econtext->ecxt_per_tuple_memory =
259 "ExprContext",
260 minContextSize,
261 initBlockSize,
262 maxBlockSize);
263
264 econtext->ecxt_param_exec_vals = estate->es_param_exec_vals;
265 econtext->ecxt_param_list_info = estate->es_param_list_info;
266
267 econtext->ecxt_aggvalues = NULL;
268 econtext->ecxt_aggnulls = NULL;
269
270 econtext->caseValue_datum = (Datum) 0;
271 econtext->caseValue_isNull = true;
272
273 econtext->domainValue_datum = (Datum) 0;
274 econtext->domainValue_isNull = true;
275
276 econtext->ecxt_estate = estate;
277
278 econtext->ecxt_callbacks = NULL;
279
280 /*
281 * Link the ExprContext into the EState to ensure it is shut down when the
282 * EState is freed. Because we use lcons(), shutdowns will occur in
283 * reverse order of creation, which may not be essential but can't hurt.
284 */
285 estate->es_exprcontexts = lcons(econtext, estate->es_exprcontexts);
286
287 MemoryContextSwitchTo(oldcontext);
288
289 return econtext;
290}
List * lcons(void *datum, List *list)
Definition: list.c:495
uintptr_t Datum
Definition: postgres.h:64
Datum domainValue_datum
Definition: execnodes.h:289
ParamListInfo ecxt_param_list_info
Definition: execnodes.h:270
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:266
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:260
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:269
Datum * ecxt_aggvalues
Definition: execnodes.h:277
bool caseValue_isNull
Definition: execnodes.h:285
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:258
Datum caseValue_datum
Definition: execnodes.h:283
bool * ecxt_aggnulls
Definition: execnodes.h:279
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:265
ExprContext_CB * ecxt_callbacks
Definition: execnodes.h:297
bool domainValue_isNull
Definition: execnodes.h:291
struct EState * ecxt_estate
Definition: execnodes.h:294
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:262

References AllocSetContextCreate, ExprContext::caseValue_datum, ExprContext::caseValue_isNull, 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, EState::es_exprcontexts, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_query_cxt, lcons(), makeNode, and MemoryContextSwitchTo().

Referenced by CreateExprContext(), and CreateWorkExprContext().

◆ CreateStandaloneExprContext()

ExprContext * CreateStandaloneExprContext ( void  )

Definition at line 357 of file execUtils.c.

358{
359 ExprContext *econtext;
360
361 /* Create the ExprContext node within the caller's memory context */
362 econtext = makeNode(ExprContext);
363
364 /* Initialize fields of ExprContext */
365 econtext->ecxt_scantuple = NULL;
366 econtext->ecxt_innertuple = NULL;
367 econtext->ecxt_outertuple = NULL;
368
370
371 /*
372 * Create working memory for expression evaluation in this context.
373 */
374 econtext->ecxt_per_tuple_memory =
376 "ExprContext",
378
379 econtext->ecxt_param_exec_vals = NULL;
380 econtext->ecxt_param_list_info = NULL;
381
382 econtext->ecxt_aggvalues = NULL;
383 econtext->ecxt_aggnulls = NULL;
384
385 econtext->caseValue_datum = (Datum) 0;
386 econtext->caseValue_isNull = true;
387
388 econtext->domainValue_datum = (Datum) 0;
389 econtext->domainValue_isNull = true;
390
391 econtext->ecxt_estate = NULL;
392
393 econtext->ecxt_callbacks = NULL;
394
395 return econtext;
396}

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

322{
323 Size minContextSize = ALLOCSET_DEFAULT_MINSIZE;
324 Size initBlockSize = ALLOCSET_DEFAULT_INITSIZE;
325 Size maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
326
327 /* choose the maxBlockSize to be no larger than 1/16 of work_mem */
328 while (16 * maxBlockSize > work_mem * 1024L)
329 maxBlockSize >>= 1;
330
331 if (maxBlockSize < ALLOCSET_DEFAULT_INITSIZE)
332 maxBlockSize = ALLOCSET_DEFAULT_INITSIZE;
333
334 return CreateExprContextInternal(estate, minContextSize,
335 initBlockSize, maxBlockSize);
336}
size_t Size
Definition: c.h:559
int work_mem
Definition: globals.c:130
#define ALLOCSET_DEFAULT_MAXSIZE
Definition: memutils.h:159
#define ALLOCSET_DEFAULT_MINSIZE
Definition: memutils.h:157
#define ALLOCSET_DEFAULT_INITSIZE
Definition: memutils.h:158

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

Referenced by ExecInitAgg().

◆ ExecAssignExprContext()

◆ ExecAssignProjectionInfo()

void ExecAssignProjectionInfo ( PlanState planstate,
TupleDesc  inputDesc 
)

Definition at line 583 of file execUtils.c.

585{
586 planstate->ps_ProjInfo =
588 planstate->ps_ExprContext,
589 planstate->ps_ResultTupleSlot,
590 planstate,
591 inputDesc);
592}
ProjectionInfo * ExecBuildProjectionInfo(List *targetList, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent, TupleDesc inputDesc)
Definition: execExpr.c:365
Plan * plan
Definition: execnodes.h:1126
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:1164
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1166
List * targetlist
Definition: plannodes.h:153

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

◆ ExecAssignScanType()

void ExecAssignScanType ( ScanState scanstate,
TupleDesc  tupDesc 
)

Definition at line 692 of file execUtils.c.

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

References ExecSetSlotDescriptor(), and ScanState::ss_ScanTupleSlot.

Referenced by ExecWorkTableScan().

◆ ExecCleanTargetListLength()

int ExecCleanTargetListLength ( List targetlist)

Definition at line 1164 of file execUtils.c.

1165{
1166 int len = 0;
1167 ListCell *tl;
1168
1169 foreach(tl, targetlist)
1170 {
1171 TargetEntry *curTle = lfirst_node(TargetEntry, tl);
1172
1173 if (!curTle->resjunk)
1174 len++;
1175 }
1176 return len;
1177}
const void size_t len
#define lfirst_node(type, lc)
Definition: pg_list.h:176

References len, and lfirst_node.

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

◆ ExecConditionalAssignProjectionInfo()

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

Definition at line 603 of file execUtils.c.

605{
606 if (tlist_matches_tupdesc(planstate,
607 planstate->plan->targetlist,
608 varno,
609 inputDesc))
610 {
611 planstate->ps_ProjInfo = NULL;
612 planstate->resultopsset = planstate->scanopsset;
613 planstate->resultopsfixed = planstate->scanopsfixed;
614 planstate->resultops = planstate->scanops;
615 }
616 else
617 {
618 if (!planstate->ps_ResultTupleSlot)
619 {
621 planstate->resultops = &TTSOpsVirtual;
622 planstate->resultopsfixed = true;
623 planstate->resultopsset = true;
624 }
625 ExecAssignProjectionInfo(planstate, inputDesc);
626 }
627}
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
void ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1966
static bool tlist_matches_tupdesc(PlanState *ps, List *tlist, int varno, TupleDesc tupdesc)
Definition: execUtils.c:630
void ExecAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc)
Definition: execUtils.c:583
const TupleTableSlotOps * resultops
Definition: execnodes.h:1203
bool resultopsset
Definition: execnodes.h:1211
const TupleTableSlotOps * scanops
Definition: execnodes.h:1200
bool scanopsset
Definition: execnodes.h:1208
bool scanopsfixed
Definition: execnodes.h:1204
bool resultopsfixed
Definition: execnodes.h:1207

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

◆ ExecCreateScanSlotFromOuterPlan()

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

Definition at line 704 of file execUtils.c.

707{
709 TupleDesc tupDesc;
710
711 outerPlan = outerPlanState(scanstate);
712 tupDesc = ExecGetResultType(outerPlan);
713
714 ExecInitScanTupleSlot(estate, scanstate, tupDesc, tts_ops);
715}
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1998
TupleDesc ExecGetResultType(PlanState *planstate)
Definition: execUtils.c:495
#define outerPlanState(node)
Definition: execnodes.h:1222
#define outerPlan(node)
Definition: plannodes.h:183

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

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

◆ ExecGetAllUpdatedCols()

Bitmapset * ExecGetAllUpdatedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1369 of file execUtils.c.

1370{
1371 Bitmapset *ret;
1372 MemoryContext oldcxt;
1373
1375
1376 ret = bms_union(ExecGetUpdatedCols(relinfo, estate),
1377 ExecGetExtraUpdatedCols(relinfo, estate));
1378
1379 MemoryContextSwitchTo(oldcxt);
1380
1381 return ret;
1382}
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:251
Bitmapset * ExecGetExtraUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1354
Bitmapset * ExecGetUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1333
#define GetPerTupleMemoryContext(estate)
Definition: executor.h:568

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

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

◆ ExecGetChildToRootMap()

TupleConversionMap * ExecGetChildToRootMap ( ResultRelInfo resultRelInfo)

Definition at line 1251 of file execUtils.c.

1252{
1253 /* If we didn't already do so, compute the map for this child. */
1254 if (!resultRelInfo->ri_ChildToRootMapValid)
1255 {
1256 ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1257
1258 if (rootRelInfo)
1259 resultRelInfo->ri_ChildToRootMap =
1261 RelationGetDescr(rootRelInfo->ri_RelationDesc));
1262 else /* this isn't a child result rel */
1263 resultRelInfo->ri_ChildToRootMap = NULL;
1264
1265 resultRelInfo->ri_ChildToRootMapValid = true;
1266 }
1267
1268 return resultRelInfo->ri_ChildToRootMap;
1269}
#define RelationGetDescr(relation)
Definition: rel.h:531
struct ResultRelInfo * ri_RootResultRelInfo
Definition: execnodes.h:590
Relation ri_RelationDesc
Definition: execnodes.h:459
TupleConversionMap * ri_ChildToRootMap
Definition: execnodes.h:570
bool ri_ChildToRootMapValid
Definition: execnodes.h:571
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(), and TransitionTableAddTuple().

◆ ExecGetCommonChildSlotOps()

const TupleTableSlotOps * ExecGetCommonChildSlotOps ( PlanState ps)

Definition at line 563 of file execUtils.c.

564{
565 PlanState *planstates[2];
566
567 planstates[0] = outerPlanState(ps);
568 planstates[1] = innerPlanState(ps);
569 return ExecGetCommonSlotOps(planstates, 2);
570}
const TupleTableSlotOps * ExecGetCommonSlotOps(PlanState **planstates, int nplans)
Definition: execUtils.c:536
#define innerPlanState(node)
Definition: execnodes.h:1221
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 536 of file execUtils.c.

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

References ExecGetResultSlotOps(), and i.

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

◆ ExecGetExtraUpdatedCols()

Bitmapset * ExecGetExtraUpdatedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1354 of file execUtils.c.

1355{
1356 /* Compute the info if we didn't already */
1357 if (relinfo->ri_GeneratedExprsU == NULL)
1358 ExecInitStoredGenerated(relinfo, estate, CMD_UPDATE);
1359 return relinfo->ri_extraUpdatedCols;
1360}
void ExecInitStoredGenerated(ResultRelInfo *resultRelInfo, EState *estate, CmdType cmdtype)
@ CMD_UPDATE
Definition: nodes.h:266
Bitmapset * ri_extraUpdatedCols
Definition: execnodes.h:477
ExprState ** ri_GeneratedExprsU
Definition: execnodes.h:537

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

Referenced by ExecGetAllUpdatedCols(), and index_unchanged_by_update().

◆ ExecGetInsertedCols()

Bitmapset * ExecGetInsertedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1312 of file execUtils.c.

1313{
1314 RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
1315
1316 if (perminfo == NULL)
1317 return NULL;
1318
1319 /* Map the columns to child's attribute numbers if needed. */
1320 if (relinfo->ri_RootResultRelInfo)
1321 {
1322 TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
1323
1324 if (map)
1325 return execute_attr_map_cols(map->attrMap, perminfo->insertedCols);
1326 }
1327
1328 return perminfo->insertedCols;
1329}
TupleConversionMap * ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate)
Definition: execUtils.c:1277
static RTEPermissionInfo * GetResultRTEPermissionInfo(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1389
Bitmapset * insertedCols
Definition: parsenodes.h:1294
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(), and ExecWithCheckOptions().

◆ ExecGetRangeTableRelation()

Relation ExecGetRangeTableRelation ( EState estate,
Index  rti 
)

Definition at line 807 of file execUtils.c.

808{
809 Relation rel;
810
811 Assert(rti > 0 && rti <= estate->es_range_table_size);
812
813 rel = estate->es_relations[rti - 1];
814 if (rel == NULL)
815 {
816 /* First time through, so open the relation */
817 RangeTblEntry *rte = exec_rt_fetch(rti, estate);
818
819 Assert(rte->rtekind == RTE_RELATION);
820
821 if (!IsParallelWorker())
822 {
823 /*
824 * In a normal query, we should already have the appropriate lock,
825 * but verify that through an Assert. Since there's already an
826 * Assert inside table_open that insists on holding some lock, it
827 * seems sufficient to check this only when rellockmode is higher
828 * than the minimum.
829 */
830 rel = table_open(rte->relid, NoLock);
831 Assert(rte->rellockmode == AccessShareLock ||
832 CheckRelationLockedByMe(rel, rte->rellockmode, false));
833 }
834 else
835 {
836 /*
837 * If we are a parallel worker, we need to obtain our own local
838 * lock on the relation. This ensures sane behavior in case the
839 * parent process exits before we do.
840 */
841 rel = table_open(rte->relid, rte->rellockmode);
842 }
843
844 estate->es_relations[rti - 1] = rel;
845 }
846
847 return rel;
848}
#define Assert(condition)
Definition: c.h:812
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition: executor.h:603
#define IsParallelWorker()
Definition: parallel.h:60
bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode, bool orstronger)
Definition: lmgr.c:329
#define NoLock
Definition: lockdefs.h:34
#define AccessShareLock
Definition: lockdefs.h:36
@ RTE_RELATION
Definition: parsenodes.h:1017
RTEKind rtekind
Definition: parsenodes.h:1047
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40

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

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

◆ ExecGetResultRelCheckAsUser()

Oid ExecGetResultRelCheckAsUser ( ResultRelInfo relInfo,
EState estate 
)

Definition at line 1440 of file execUtils.c.

1441{
1442 RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relInfo, estate);
1443
1444 /* XXX - maybe ok to return GetUserId() in this case? */
1445 if (perminfo == NULL)
1446 elog(ERROR, "no RTEPermissionInfo found for result relation with OID %u",
1448
1449 return perminfo->checkAsUser ? perminfo->checkAsUser : GetUserId();
1450}
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
Oid GetUserId(void)
Definition: miscinit.c:517
#define RelationGetRelid(relation)
Definition: rel.h:505

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

505{
506 if (planstate->resultopsset && planstate->resultops)
507 {
508 if (isfixed)
509 *isfixed = planstate->resultopsfixed;
510 return planstate->resultops;
511 }
512
513 if (isfixed)
514 {
515 if (planstate->resultopsset)
516 *isfixed = planstate->resultopsfixed;
517 else if (planstate->ps_ResultTupleSlot)
518 *isfixed = TTS_FIXED(planstate->ps_ResultTupleSlot);
519 else
520 *isfixed = false;
521 }
522
523 if (!planstate->ps_ResultTupleSlot)
524 return &TTSOpsVirtual;
525
526 return planstate->ps_ResultTupleSlot->tts_ops;
527}
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 1227 of file execUtils.c.

1228{
1229 if (relInfo->ri_ReturningSlot == NULL)
1230 {
1231 Relation rel = relInfo->ri_RelationDesc;
1232 MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1233
1234 relInfo->ri_ReturningSlot =
1236 RelationGetDescr(rel),
1238
1239 MemoryContextSwitchTo(oldcontext);
1240 }
1241
1242 return relInfo->ri_ReturningSlot;
1243}
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:2018
TupleTableSlot * ri_ReturningSlot
Definition: execnodes.h:504
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
Definition: tableam.c:58

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

1278{
1279 /* Mustn't get called for a non-child result relation. */
1280 Assert(resultRelInfo->ri_RootResultRelInfo);
1281
1282 /* If we didn't already do so, compute the map for this child. */
1283 if (!resultRelInfo->ri_RootToChildMapValid)
1284 {
1285 ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1286 TupleDesc indesc = RelationGetDescr(rootRelInfo->ri_RelationDesc);
1287 TupleDesc outdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
1288 Relation childrel = resultRelInfo->ri_RelationDesc;
1289 AttrMap *attrMap;
1290 MemoryContext oldcontext;
1291
1292 /*
1293 * When this child table is not a partition (!relispartition), it may
1294 * have columns that are not present in the root table, which we ask
1295 * to ignore by passing true for missing_ok.
1296 */
1297 oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1298 attrMap = build_attrmap_by_name_if_req(indesc, outdesc,
1299 !childrel->rd_rel->relispartition);
1300 if (attrMap)
1301 resultRelInfo->ri_RootToChildMap =
1302 convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
1303 MemoryContextSwitchTo(oldcontext);
1304 resultRelInfo->ri_RootToChildMapValid = true;
1305 }
1306
1307 return resultRelInfo->ri_RootToChildMap;
1308}
AttrMap * build_attrmap_by_name_if_req(TupleDesc indesc, TupleDesc outdesc, bool missing_ok)
Definition: attmap.c:263
Definition: attmap.h:35
Form_pg_class rd_rel
Definition: rel.h:111
TupleConversionMap * ri_RootToChildMap
Definition: execnodes.h:576
bool ri_RootToChildMapValid
Definition: execnodes.h:577
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(), and ExecPrepareTupleRouting().

◆ ExecGetTriggerNewSlot()

TupleTableSlot * ExecGetTriggerNewSlot ( EState estate,
ResultRelInfo relInfo 
)

Definition at line 1205 of file execUtils.c.

1206{
1207 if (relInfo->ri_TrigNewSlot == NULL)
1208 {
1209 Relation rel = relInfo->ri_RelationDesc;
1210 MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1211
1212 relInfo->ri_TrigNewSlot =
1214 RelationGetDescr(rel),
1216
1217 MemoryContextSwitchTo(oldcontext);
1218 }
1219
1220 return relInfo->ri_TrigNewSlot;
1221}
TupleTableSlot * ri_TrigNewSlot
Definition: execnodes.h:506

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 
)

◆ ExecGetUpdatedCols()

Bitmapset * ExecGetUpdatedCols ( ResultRelInfo relinfo,
EState estate 
)

Definition at line 1333 of file execUtils.c.

1334{
1335 RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
1336
1337 if (perminfo == NULL)
1338 return NULL;
1339
1340 /* Map the columns to child's attribute numbers if needed. */
1341 if (relinfo->ri_RootResultRelInfo)
1342 {
1343 TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
1344
1345 if (map)
1346 return execute_attr_map_cols(map->attrMap, perminfo->updatedCols);
1347 }
1348
1349 return perminfo->updatedCols;
1350}
Bitmapset * updatedCols
Definition: parsenodes.h:1295

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

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

◆ ExecInitRangeTable()

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

Definition at line 773 of file execUtils.c.

774{
775 /* Remember the range table List as-is */
776 estate->es_range_table = rangeTable;
777
778 /* ... and the RTEPermissionInfo List too */
779 estate->es_rteperminfos = permInfos;
780
781 /* Set size of associated arrays */
782 estate->es_range_table_size = list_length(rangeTable);
783
784 /*
785 * Allocate an array to store an open Relation corresponding to each
786 * rangetable entry, and initialize entries to NULL. Relations are opened
787 * and stored here as needed.
788 */
789 estate->es_relations = (Relation *)
790 palloc0(estate->es_range_table_size * sizeof(Relation));
791
792 /*
793 * es_result_relations and es_rowmarks are also parallel to
794 * es_range_table, but are allocated only if needed.
795 */
796 estate->es_result_relations = NULL;
797 estate->es_rowmarks = NULL;
798}
void * palloc0(Size size)
Definition: mcxt.c:1347
static int list_length(const List *l)
Definition: pg_list.h:152

References EState::es_range_table, EState::es_range_table_size, EState::es_relations, EState::es_result_relations, EState::es_rowmarks, EState::es_rteperminfos, 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 859 of file execUtils.c.

861{
862 Relation resultRelationDesc;
863
864 resultRelationDesc = ExecGetRangeTableRelation(estate, rti);
865 InitResultRelInfo(resultRelInfo,
866 resultRelationDesc,
867 rti,
868 NULL,
869 estate->es_instrument);
870
871 if (estate->es_result_relations == NULL)
873 palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *));
874 estate->es_result_relations[rti - 1] = resultRelInfo;
875
876 /*
877 * Saving in the list allows to avoid needlessly traversing the whole
878 * array when only a few of its entries are possibly non-NULL.
879 */
881 lappend(estate->es_opened_result_relations, resultRelInfo);
882}
void InitResultRelInfo(ResultRelInfo *resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo *partition_root_rri, int instrument_options)
Definition: execMain.c:1203
Relation ExecGetRangeTableRelation(EState *estate, Index rti)
Definition: execUtils.c:807
List * lappend(List *list, void *datum)
Definition: list.c:339

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

◆ ExecOpenScanRelation()

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

Definition at line 742 of file execUtils.c.

743{
744 Relation rel;
745
746 /* Open the relation. */
747 rel = ExecGetRangeTableRelation(estate, scanrelid);
748
749 /*
750 * Complain if we're attempting a scan of an unscannable relation, except
751 * when the query won't actually be run. This is a slightly klugy place
752 * to do this, perhaps, but there is no better place.
753 */
754 if ((eflags & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA)) == 0 &&
757 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
758 errmsg("materialized view \"%s\" has not been populated",
760 errhint("Use the REFRESH MATERIALIZED VIEW command.")));
761
762 return rel;
763}
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ereport(elevel,...)
Definition: elog.h:149
#define EXEC_FLAG_WITH_NO_DATA
Definition: executor.h:71
#define EXEC_FLAG_EXPLAIN_ONLY
Definition: executor.h:65
#define RelationIsScannable(relation)
Definition: rel.h:669
#define RelationGetRelationName(relation)
Definition: rel.h:539

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

◆ ExecRelationIsTargetRelation()

bool ExecRelationIsTargetRelation ( EState estate,
Index  scanrelid 
)

Definition at line 729 of file execUtils.c.

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

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

◆ ExecTargetListLength()

int ExecTargetListLength ( List targetlist)

Definition at line 1154 of file execUtils.c.

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

References list_length().

Referenced by ExecTypeFromTLInternal().

◆ executor_errposition()

int executor_errposition ( EState estate,
int  location 
)

Definition at line 915 of file execUtils.c.

916{
917 int pos;
918
919 /* No-op if location was not provided */
920 if (location < 0)
921 return 0;
922 /* Can't do anything if source text is not available */
923 if (estate == NULL || estate->es_sourceText == NULL)
924 return 0;
925 /* Convert offset to character number */
926 pos = pg_mbstrlen_with_len(estate->es_sourceText, location) + 1;
927 /* And pass it to the ereport mechanism */
928 return errposition(pos);
929}
int errposition(int cursorpos)
Definition: elog.c:1446
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().

◆ FreeExecutorState()

void FreeExecutorState ( EState estate)

Definition at line 191 of file execUtils.c.

192{
193 /*
194 * Shut down and free any remaining ExprContexts. We do this explicitly
195 * to ensure that any remaining shutdown callbacks get called (since they
196 * might need to release resources that aren't simply memory within the
197 * per-query memory context).
198 */
199 while (estate->es_exprcontexts)
200 {
201 /*
202 * XXX: seems there ought to be a faster way to implement this than
203 * repeated list_delete(), no?
204 */
206 true);
207 /* FreeExprContext removed the list link for us */
208 }
209
210 /* release JIT context, if allocated */
211 if (estate->es_jit)
212 {
214 estate->es_jit = NULL;
215 }
216
217 /* release partition directory, if allocated */
218 if (estate->es_partition_directory)
219 {
221 estate->es_partition_directory = NULL;
222 }
223
224 /*
225 * Free the per-query memory context, thereby releasing all working
226 * memory, including the EState node itself.
227 */
229}
void FreeExprContext(ExprContext *econtext, bool isCommit)
Definition: execUtils.c:416
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
#define linitial(l)
Definition: pg_list.h:178
PartitionDirectory es_partition_directory
Definition: execnodes.h:657

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(), 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(), StoreAttrDefault(), and validateDomainCheckConstraint().

◆ FreeExprContext()

void FreeExprContext ( ExprContext econtext,
bool  isCommit 
)

Definition at line 416 of file execUtils.c.

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

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

1041{
1042 AttrNumber attrno;
1043 Datum result;
1044 Oid tupType;
1045 int32 tupTypmod;
1046 TupleDesc tupDesc;
1047 HeapTupleData tmptup;
1048 int i;
1049
1050 if (attname == NULL)
1051 elog(ERROR, "invalid attribute name");
1052
1053 if (isNull == NULL)
1054 elog(ERROR, "a NULL isNull pointer was passed");
1055
1056 if (tuple == NULL)
1057 {
1058 /* Kinda bogus but compatible with old behavior... */
1059 *isNull = true;
1060 return (Datum) 0;
1061 }
1062
1063 tupType = HeapTupleHeaderGetTypeId(tuple);
1064 tupTypmod = HeapTupleHeaderGetTypMod(tuple);
1065 tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1066
1067 attrno = InvalidAttrNumber;
1068 for (i = 0; i < tupDesc->natts; i++)
1069 {
1070 Form_pg_attribute att = TupleDescAttr(tupDesc, i);
1071
1072 if (namestrcmp(&(att->attname), attname) == 0)
1073 {
1074 attrno = att->attnum;
1075 break;
1076 }
1077 }
1078
1079 if (attrno == InvalidAttrNumber)
1080 elog(ERROR, "attribute \"%s\" does not exist", attname);
1081
1082 /*
1083 * heap_getattr needs a HeapTuple not a bare HeapTupleHeader. We set all
1084 * the fields in the struct just in case user tries to inspect system
1085 * columns.
1086 */
1087 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
1088 ItemPointerSetInvalid(&(tmptup.t_self));
1089 tmptup.t_tableOid = InvalidOid;
1090 tmptup.t_data = tuple;
1091
1092 result = heap_getattr(&tmptup,
1093 attrno,
1094 tupDesc,
1095 isNull);
1096
1097 ReleaseTupleDesc(tupDesc);
1098
1099 return result;
1100}
int16 AttrNumber
Definition: attnum.h:21
#define InvalidAttrNumber
Definition: attnum.h:23
int32_t int32
Definition: c.h:481
static Datum heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:792
#define HeapTupleHeaderGetTypMod(tup)
Definition: htup_details.h:466
#define HeapTupleHeaderGetTypeId(tup)
Definition: htup_details.h:456
#define HeapTupleHeaderGetDatumLength(tup)
Definition: htup_details.h:450
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
int namestrcmp(Name name, const char *str)
Definition: name.c:247
NameData attname
Definition: pg_attribute.h:41
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:200
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
ItemPointerData t_self
Definition: htup.h:65
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
Oid t_tableOid
Definition: htup.h:66
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:213
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:152
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition: typcache.c:1920

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

1106{
1107 Datum result;
1108 Oid tupType;
1109 int32 tupTypmod;
1110 TupleDesc tupDesc;
1111 HeapTupleData tmptup;
1112
1113 if (!AttributeNumberIsValid(attrno))
1114 elog(ERROR, "invalid attribute number %d", attrno);
1115
1116 if (isNull == NULL)
1117 elog(ERROR, "a NULL isNull pointer was passed");
1118
1119 if (tuple == NULL)
1120 {
1121 /* Kinda bogus but compatible with old behavior... */
1122 *isNull = true;
1123 return (Datum) 0;
1124 }
1125
1126 tupType = HeapTupleHeaderGetTypeId(tuple);
1127 tupTypmod = HeapTupleHeaderGetTypMod(tuple);
1128 tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1129
1130 /*
1131 * heap_getattr needs a HeapTuple not a bare HeapTupleHeader. We set all
1132 * the fields in the struct just in case user tries to inspect system
1133 * columns.
1134 */
1135 tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
1136 ItemPointerSetInvalid(&(tmptup.t_self));
1137 tmptup.t_tableOid = InvalidOid;
1138 tmptup.t_data = tuple;
1139
1140 result = heap_getattr(&tmptup,
1141 attrno,
1142 tupDesc,
1143 isNull);
1144
1145 ReleaseTupleDesc(tupDesc);
1146
1147 return result;
1148}
#define AttributeNumberIsValid(attributeNumber)
Definition: attnum.h:34

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.

◆ GetResultRTEPermissionInfo()

static RTEPermissionInfo * GetResultRTEPermissionInfo ( ResultRelInfo relinfo,
EState estate 
)
static

Definition at line 1389 of file execUtils.c.

1390{
1391 Index rti;
1392 RangeTblEntry *rte;
1393 RTEPermissionInfo *perminfo = NULL;
1394
1395 if (relinfo->ri_RootResultRelInfo)
1396 {
1397 /*
1398 * For inheritance child result relations (a partition routing target
1399 * of an INSERT or a child UPDATE target), this returns the root
1400 * parent's RTE to fetch the RTEPermissionInfo because that's the only
1401 * one that has one assigned.
1402 */
1404 }
1405 else if (relinfo->ri_RangeTableIndex != 0)
1406 {
1407 /*
1408 * Non-child result relation should have their own RTEPermissionInfo.
1409 */
1410 rti = relinfo->ri_RangeTableIndex;
1411 }
1412 else
1413 {
1414 /*
1415 * The relation isn't in the range table and it isn't a partition
1416 * routing target. This ResultRelInfo must've been created only for
1417 * firing triggers and the relation is not being inserted into. (See
1418 * ExecGetTriggerResultRel.)
1419 */
1420 rti = 0;
1421 }
1422
1423 if (rti > 0)
1424 {
1425 rte = exec_rt_fetch(rti, estate);
1426 perminfo = getRTEPermissionInfo(estate->es_rteperminfos, rte);
1427 }
1428
1429 return perminfo;
1430}
unsigned int Index
Definition: c.h:568
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
Index ri_RangeTableIndex
Definition: execnodes.h:456

References EState::es_rteperminfos, exec_rt_fetch(), getRTEPermissionInfo(), ResultRelInfo::ri_RangeTableIndex, and ResultRelInfo::ri_RootResultRelInfo.

Referenced by ExecGetInsertedCols(), ExecGetResultRelCheckAsUser(), and ExecGetUpdatedCols().

◆ MakePerTupleExprContext()

ExprContext * MakePerTupleExprContext ( EState estate)

Definition at line 458 of file execUtils.c.

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

References CreateExprContext(), and EState::es_per_tuple_exprcontext.

◆ RegisterExprContextCallback()

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

Definition at line 942 of file execUtils.c.

945{
946 ExprContext_CB *ecxt_callback;
947
948 /* Save the info in appropriate memory context */
949 ecxt_callback = (ExprContext_CB *)
951 sizeof(ExprContext_CB));
952
953 ecxt_callback->function = function;
954 ecxt_callback->arg = arg;
955
956 /* link to front of list for appropriate execution order */
957 ecxt_callback->next = econtext->ecxt_callbacks;
958 econtext->ecxt_callbacks = ecxt_callback;
959}
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
on_exit_nicely_callback function
void * arg
struct ExprContext_CB * next
Definition: execnodes.h:224
ExprContextCallbackFunction function
Definition: execnodes.h:225

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

◆ ReScanExprContext()

void ReScanExprContext ( ExprContext econtext)

Definition at line 443 of file execUtils.c.

444{
445 /* Call any registered callbacks */
446 ShutdownExprContext(econtext, true);
447 /* And clean up the memory used */
449}
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383

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

◆ ShutdownExprContext()

static void ShutdownExprContext ( ExprContext econtext,
bool  isCommit 
)
static

Definition at line 999 of file execUtils.c.

1000{
1001 ExprContext_CB *ecxt_callback;
1002 MemoryContext oldcontext;
1003
1004 /* Fast path in normal case where there's nothing to do. */
1005 if (econtext->ecxt_callbacks == NULL)
1006 return;
1007
1008 /*
1009 * Call the callbacks in econtext's per-tuple context. This ensures that
1010 * any memory they might leak will get cleaned up.
1011 */
1012 oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
1013
1014 /*
1015 * Call each callback function in reverse registration order.
1016 */
1017 while ((ecxt_callback = econtext->ecxt_callbacks) != NULL)
1018 {
1019 econtext->ecxt_callbacks = ecxt_callback->next;
1020 if (isCommit)
1021 ecxt_callback->function(ecxt_callback->arg);
1022 pfree(ecxt_callback);
1023 }
1024
1025 MemoryContextSwitchTo(oldcontext);
1026}

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

Referenced by FreeExprContext(), and ReScanExprContext().

◆ tlist_matches_tupdesc()

static bool tlist_matches_tupdesc ( PlanState ps,
List tlist,
int  varno,
TupleDesc  tupdesc 
)
static

Definition at line 630 of file execUtils.c.

631{
632 int numattrs = tupdesc->natts;
633 int attrno;
634 ListCell *tlist_item = list_head(tlist);
635
636 /* Check the tlist attributes */
637 for (attrno = 1; attrno <= numattrs; attrno++)
638 {
639 Form_pg_attribute att_tup = TupleDescAttr(tupdesc, attrno - 1);
640 Var *var;
641
642 if (tlist_item == NULL)
643 return false; /* tlist too short */
644 var = (Var *) ((TargetEntry *) lfirst(tlist_item))->expr;
645 if (!var || !IsA(var, Var))
646 return false; /* tlist item not a Var */
647 /* if these Asserts fail, planner messed up */
648 Assert(var->varno == varno);
649 Assert(var->varlevelsup == 0);
650 if (var->varattno != attrno)
651 return false; /* out of order */
652 if (att_tup->attisdropped)
653 return false; /* table contains dropped columns */
654 if (att_tup->atthasmissing)
655 return false; /* table contains cols with missing values */
656
657 /*
658 * Note: usually the Var's type should match the tupdesc exactly, but
659 * in situations involving unions of columns that have different
660 * typmods, the Var may have come from above the union and hence have
661 * typmod -1. This is a legitimate situation since the Var still
662 * describes the column, just not as exactly as the tupdesc does. We
663 * could change the planner to prevent it, but it'd then insert
664 * projection steps just to convert from specific typmod to typmod -1,
665 * which is pretty silly.
666 */
667 if (var->vartype != att_tup->atttypid ||
668 (var->vartypmod != att_tup->atttypmod &&
669 var->vartypmod != -1))
670 return false; /* type mismatch */
671
672 tlist_item = lnext(tlist, tlist_item);
673 }
674
675 if (tlist_item)
676 return false; /* tlist too long */
677
678 return true;
679}
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define lfirst(lc)
Definition: pg_list.h:172
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
Definition: primnodes.h:248
AttrNumber varattno
Definition: primnodes.h:260
int varno
Definition: primnodes.h:255
Index varlevelsup
Definition: primnodes.h:280

References Assert, IsA, lfirst, list_head(), lnext(), TupleDescData::natts, TupleDescAttr(), Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by ExecConditionalAssignProjectionInfo().

◆ UnregisterExprContextCallback()

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

Definition at line 968 of file execUtils.c.

971{
972 ExprContext_CB **prev_callback;
973 ExprContext_CB *ecxt_callback;
974
975 prev_callback = &econtext->ecxt_callbacks;
976
977 while ((ecxt_callback = *prev_callback) != NULL)
978 {
979 if (ecxt_callback->function == function && ecxt_callback->arg == arg)
980 {
981 *prev_callback = ecxt_callback->next;
982 pfree(ecxt_callback);
983 }
984 else
985 prev_callback = &ecxt_callback->next;
986 }
987}

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

890{
891 Bitmapset *parmset;
892
893 /*
894 * The plan node only depends on params listed in its allParam set. Don't
895 * include anything else into its chgParam set.
896 */
897 parmset = bms_intersect(node->plan->allParam, newchg);
898 node->chgParam = bms_join(node->chgParam, parmset);
899}
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 * chgParam
Definition: execnodes.h:1158
Bitmapset * allParam
Definition: plannodes.h:172

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

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