PostgreSQL Source Code  git master
execUtils.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * execUtils.c
4  * miscellaneous executor utility routines
5  *
6  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/executor/execUtils.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 /*
16  * INTERFACE ROUTINES
17  * CreateExecutorState Create/delete executor working state
18  * FreeExecutorState
19  * CreateExprContext
20  * CreateStandaloneExprContext
21  * FreeExprContext
22  * ReScanExprContext
23  *
24  * ExecAssignExprContext Common code for plan node init routines.
25  * etc
26  *
27  * ExecOpenScanRelation Common code for scan node init routines.
28  *
29  * ExecInitRangeTable Set up executor's range-table-related data.
30  *
31  * ExecGetRangeTableRelation Fetch Relation for a rangetable entry.
32  *
33  * executor_errposition Report syntactic position of an error.
34  *
35  * RegisterExprContextCallback Register function shutdown callback
36  * UnregisterExprContextCallback Deregister function shutdown callback
37  *
38  * GetAttributeByName Runtime extraction of columns from tuples.
39  * GetAttributeByNum
40  *
41  * NOTES
42  * This file has traditionally been the place to stick misc.
43  * executor support stuff that doesn't really go anyplace else.
44  */
45 
46 #include "postgres.h"
47 
48 #include "access/parallel.h"
49 #include "access/relscan.h"
50 #include "access/table.h"
51 #include "access/tableam.h"
52 #include "access/transam.h"
53 #include "executor/executor.h"
54 #include "executor/execPartition.h"
56 #include "jit/jit.h"
57 #include "mb/pg_wchar.h"
58 #include "miscadmin.h"
59 #include "nodes/nodeFuncs.h"
60 #include "parser/parsetree.h"
61 #include "parser/parse_relation.h"
62 #include "partitioning/partdesc.h"
63 #include "storage/lmgr.h"
64 #include "utils/builtins.h"
65 #include "utils/memutils.h"
66 #include "utils/rel.h"
67 #include "utils/typcache.h"
68 
69 
70 static bool tlist_matches_tupdesc(PlanState *ps, List *tlist, int varno, TupleDesc tupdesc);
71 static void ShutdownExprContext(ExprContext *econtext, bool isCommit);
73 
74 
75 /* ----------------------------------------------------------------
76  * Executor state and memory management functions
77  * ----------------------------------------------------------------
78  */
79 
80 /* ----------------
81  * CreateExecutorState
82  *
83  * Create and initialize an EState node, which is the root of
84  * working storage for an entire Executor invocation.
85  *
86  * Principally, this creates the per-query memory context that will be
87  * used to hold all working data that lives till the end of the query.
88  * Note that the per-query context will become a child of the caller's
89  * CurrentMemoryContext.
90  * ----------------
91  */
92 EState *
94 {
95  EState *estate;
96  MemoryContext qcontext;
97  MemoryContext oldcontext;
98 
99  /*
100  * Create the per-query context for this Executor run.
101  */
103  "ExecutorState",
105 
106  /*
107  * Make the EState node within the per-query context. This way, we don't
108  * need a separate pfree() operation for it at shutdown.
109  */
110  oldcontext = MemoryContextSwitchTo(qcontext);
111 
112  estate = makeNode(EState);
113 
114  /*
115  * Initialize all fields of the Executor State structure
116  */
118  estate->es_snapshot = InvalidSnapshot; /* caller must initialize this */
119  estate->es_crosscheck_snapshot = InvalidSnapshot; /* no crosscheck */
120  estate->es_range_table = NIL;
121  estate->es_range_table_size = 0;
122  estate->es_relations = NULL;
123  estate->es_rowmarks = NULL;
124  estate->es_rteperminfos = NIL;
125  estate->es_plannedstmt = NULL;
126  estate->es_part_prune_infos = NIL;
127 
128  estate->es_junkFilter = NULL;
129 
130  estate->es_output_cid = (CommandId) 0;
131 
132  estate->es_result_relations = NULL;
135  estate->es_trig_target_relations = NIL;
136 
139 
140  estate->es_param_list_info = NULL;
141  estate->es_param_exec_vals = NULL;
142 
143  estate->es_queryEnv = NULL;
144 
145  estate->es_query_cxt = qcontext;
146 
147  estate->es_tupleTable = NIL;
148 
149  estate->es_processed = 0;
150 
151  estate->es_top_eflags = 0;
152  estate->es_instrument = 0;
153  estate->es_finished = false;
154 
155  estate->es_exprcontexts = NIL;
156 
157  estate->es_subplanstates = NIL;
158 
159  estate->es_auxmodifytables = NIL;
160 
161  estate->es_per_tuple_exprcontext = NULL;
162 
163  estate->es_sourceText = NULL;
164 
165  estate->es_use_parallel_mode = false;
166 
167  estate->es_jit_flags = 0;
168  estate->es_jit = NULL;
169 
170  /*
171  * Return the executor state structure
172  */
173  MemoryContextSwitchTo(oldcontext);
174 
175  return estate;
176 }
177 
178 /* ----------------
179  * FreeExecutorState
180  *
181  * Release an EState along with all remaining working storage.
182  *
183  * Note: this is not responsible for releasing non-memory resources, such as
184  * open relations or buffer pins. But it will shut down any still-active
185  * ExprContexts within the EState and deallocate associated JITed expressions.
186  * That is sufficient cleanup for situations where the EState has only been
187  * used for expression evaluation, and not to run a complete Plan.
188  *
189  * This can be called in any memory context ... so long as it's not one
190  * of the ones to be freed.
191  * ----------------
192  */
193 void
195 {
196  /*
197  * Shut down and free any remaining ExprContexts. We do this explicitly
198  * to ensure that any remaining shutdown callbacks get called (since they
199  * might need to release resources that aren't simply memory within the
200  * per-query memory context).
201  */
202  while (estate->es_exprcontexts)
203  {
204  /*
205  * XXX: seems there ought to be a faster way to implement this than
206  * repeated list_delete(), no?
207  */
209  true);
210  /* FreeExprContext removed the list link for us */
211  }
212 
213  /* release JIT context, if allocated */
214  if (estate->es_jit)
215  {
216  jit_release_context(estate->es_jit);
217  estate->es_jit = NULL;
218  }
219 
220  /* release partition directory, if allocated */
221  if (estate->es_partition_directory)
222  {
224  estate->es_partition_directory = NULL;
225  }
226 
227  /*
228  * Free the per-query memory context, thereby releasing all working
229  * memory, including the EState node itself.
230  */
232 }
233 
234 /*
235  * Internal implementation for CreateExprContext() and CreateWorkExprContext()
236  * that allows control over the AllocSet parameters.
237  */
238 static ExprContext *
239 CreateExprContextInternal(EState *estate, Size minContextSize,
240  Size initBlockSize, Size maxBlockSize)
241 {
242  ExprContext *econtext;
243  MemoryContext oldcontext;
244 
245  /* Create the ExprContext node within the per-query memory context */
246  oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
247 
248  econtext = makeNode(ExprContext);
249 
250  /* Initialize fields of ExprContext */
251  econtext->ecxt_scantuple = NULL;
252  econtext->ecxt_innertuple = NULL;
253  econtext->ecxt_outertuple = NULL;
254 
255  econtext->ecxt_per_query_memory = estate->es_query_cxt;
256 
257  /*
258  * Create working memory for expression evaluation in this context.
259  */
260  econtext->ecxt_per_tuple_memory =
262  "ExprContext",
263  minContextSize,
264  initBlockSize,
265  maxBlockSize);
266 
267  econtext->ecxt_param_exec_vals = estate->es_param_exec_vals;
268  econtext->ecxt_param_list_info = estate->es_param_list_info;
269 
270  econtext->ecxt_aggvalues = NULL;
271  econtext->ecxt_aggnulls = NULL;
272 
273  econtext->caseValue_datum = (Datum) 0;
274  econtext->caseValue_isNull = true;
275 
276  econtext->domainValue_datum = (Datum) 0;
277  econtext->domainValue_isNull = true;
278 
279  econtext->ecxt_estate = estate;
280 
281  econtext->ecxt_callbacks = NULL;
282 
283  /*
284  * Link the ExprContext into the EState to ensure it is shut down when the
285  * EState is freed. Because we use lcons(), shutdowns will occur in
286  * reverse order of creation, which may not be essential but can't hurt.
287  */
288  estate->es_exprcontexts = lcons(econtext, estate->es_exprcontexts);
289 
290  MemoryContextSwitchTo(oldcontext);
291 
292  return econtext;
293 }
294 
295 /* ----------------
296  * CreateExprContext
297  *
298  * Create a context for expression evaluation within an EState.
299  *
300  * An executor run may require multiple ExprContexts (we usually make one
301  * for each Plan node, and a separate one for per-output-tuple processing
302  * such as constraint checking). Each ExprContext has its own "per-tuple"
303  * memory context.
304  *
305  * Note we make no assumption about the caller's memory context.
306  * ----------------
307  */
308 ExprContext *
310 {
312 }
313 
314 
315 /* ----------------
316  * CreateWorkExprContext
317  *
318  * Like CreateExprContext, but specifies the AllocSet sizes to be reasonable
319  * in proportion to work_mem. If the maximum block allocation size is too
320  * large, it's easy to skip right past work_mem with a single allocation.
321  * ----------------
322  */
323 ExprContext *
325 {
326  Size minContextSize = ALLOCSET_DEFAULT_MINSIZE;
327  Size initBlockSize = ALLOCSET_DEFAULT_INITSIZE;
328  Size maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
329 
330  /* choose the maxBlockSize to be no larger than 1/16 of work_mem */
331  while (16 * maxBlockSize > work_mem * 1024L)
332  maxBlockSize >>= 1;
333 
334  if (maxBlockSize < ALLOCSET_DEFAULT_INITSIZE)
335  maxBlockSize = ALLOCSET_DEFAULT_INITSIZE;
336 
337  return CreateExprContextInternal(estate, minContextSize,
338  initBlockSize, maxBlockSize);
339 }
340 
341 /* ----------------
342  * CreateStandaloneExprContext
343  *
344  * Create a context for standalone expression evaluation.
345  *
346  * An ExprContext made this way can be used for evaluation of expressions
347  * that contain no Params, subplans, or Var references (it might work to
348  * put tuple references into the scantuple field, but it seems unwise).
349  *
350  * The ExprContext struct is allocated in the caller's current memory
351  * context, which also becomes its "per query" context.
352  *
353  * It is caller's responsibility to free the ExprContext when done,
354  * or at least ensure that any shutdown callbacks have been called
355  * (ReScanExprContext() is suitable). Otherwise, non-memory resources
356  * might be leaked.
357  * ----------------
358  */
359 ExprContext *
361 {
362  ExprContext *econtext;
363 
364  /* Create the ExprContext node within the caller's memory context */
365  econtext = makeNode(ExprContext);
366 
367  /* Initialize fields of ExprContext */
368  econtext->ecxt_scantuple = NULL;
369  econtext->ecxt_innertuple = NULL;
370  econtext->ecxt_outertuple = NULL;
371 
373 
374  /*
375  * Create working memory for expression evaluation in this context.
376  */
377  econtext->ecxt_per_tuple_memory =
379  "ExprContext",
381 
382  econtext->ecxt_param_exec_vals = NULL;
383  econtext->ecxt_param_list_info = NULL;
384 
385  econtext->ecxt_aggvalues = NULL;
386  econtext->ecxt_aggnulls = NULL;
387 
388  econtext->caseValue_datum = (Datum) 0;
389  econtext->caseValue_isNull = true;
390 
391  econtext->domainValue_datum = (Datum) 0;
392  econtext->domainValue_isNull = true;
393 
394  econtext->ecxt_estate = NULL;
395 
396  econtext->ecxt_callbacks = NULL;
397 
398  return econtext;
399 }
400 
401 /* ----------------
402  * FreeExprContext
403  *
404  * Free an expression context, including calling any remaining
405  * shutdown callbacks.
406  *
407  * Since we free the temporary context used for expression evaluation,
408  * any previously computed pass-by-reference expression result will go away!
409  *
410  * If isCommit is false, we are being called in error cleanup, and should
411  * not call callbacks but only release memory. (It might be better to call
412  * the callbacks and pass the isCommit flag to them, but that would require
413  * more invasive code changes than currently seems justified.)
414  *
415  * Note we make no assumption about the caller's memory context.
416  * ----------------
417  */
418 void
419 FreeExprContext(ExprContext *econtext, bool isCommit)
420 {
421  EState *estate;
422 
423  /* Call any registered callbacks */
424  ShutdownExprContext(econtext, isCommit);
425  /* And clean up the memory used */
427  /* Unlink self from owning EState, if any */
428  estate = econtext->ecxt_estate;
429  if (estate)
431  econtext);
432  /* And delete the ExprContext node */
433  pfree(econtext);
434 }
435 
436 /*
437  * ReScanExprContext
438  *
439  * Reset an expression context in preparation for a rescan of its
440  * plan node. This requires calling any registered shutdown callbacks,
441  * since any partially complete set-returning-functions must be canceled.
442  *
443  * Note we make no assumption about the caller's memory context.
444  */
445 void
447 {
448  /* Call any registered callbacks */
449  ShutdownExprContext(econtext, true);
450  /* And clean up the memory used */
452 }
453 
454 /*
455  * Build a per-output-tuple ExprContext for an EState.
456  *
457  * This is normally invoked via GetPerTupleExprContext() macro,
458  * not directly.
459  */
460 ExprContext *
462 {
463  if (estate->es_per_tuple_exprcontext == NULL)
465 
466  return estate->es_per_tuple_exprcontext;
467 }
468 
469 
470 /* ----------------------------------------------------------------
471  * miscellaneous node-init support functions
472  *
473  * Note: all of these are expected to be called with CurrentMemoryContext
474  * equal to the per-query memory context.
475  * ----------------------------------------------------------------
476  */
477 
478 /* ----------------
479  * ExecAssignExprContext
480  *
481  * This initializes the ps_ExprContext field. It is only necessary
482  * to do this for nodes which use ExecQual or ExecProject
483  * because those routines require an econtext. Other nodes that
484  * don't have to evaluate expressions don't need to do this.
485  * ----------------
486  */
487 void
489 {
490  planstate->ps_ExprContext = CreateExprContext(estate);
491 }
492 
493 /* ----------------
494  * ExecGetResultType
495  * ----------------
496  */
497 TupleDesc
499 {
500  return planstate->ps_ResultTupleDesc;
501 }
502 
503 /*
504  * ExecGetResultSlotOps - information about node's type of result slot
505  */
506 const TupleTableSlotOps *
507 ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
508 {
509  if (planstate->resultopsset && planstate->resultops)
510  {
511  if (isfixed)
512  *isfixed = planstate->resultopsfixed;
513  return planstate->resultops;
514  }
515 
516  if (isfixed)
517  {
518  if (planstate->resultopsset)
519  *isfixed = planstate->resultopsfixed;
520  else if (planstate->ps_ResultTupleSlot)
521  *isfixed = TTS_FIXED(planstate->ps_ResultTupleSlot);
522  else
523  *isfixed = false;
524  }
525 
526  if (!planstate->ps_ResultTupleSlot)
527  return &TTSOpsVirtual;
528 
529  return planstate->ps_ResultTupleSlot->tts_ops;
530 }
531 
532 
533 /* ----------------
534  * ExecAssignProjectionInfo
535  *
536  * forms the projection information from the node's targetlist
537  *
538  * Notes for inputDesc are same as for ExecBuildProjectionInfo: supply it
539  * for a relation-scan node, can pass NULL for upper-level nodes
540  * ----------------
541  */
542 void
544  TupleDesc inputDesc)
545 {
546  planstate->ps_ProjInfo =
548  planstate->ps_ExprContext,
549  planstate->ps_ResultTupleSlot,
550  planstate,
551  inputDesc);
552 }
553 
554 
555 /* ----------------
556  * ExecConditionalAssignProjectionInfo
557  *
558  * as ExecAssignProjectionInfo, but store NULL rather than building projection
559  * info if no projection is required
560  * ----------------
561  */
562 void
564  int varno)
565 {
566  if (tlist_matches_tupdesc(planstate,
567  planstate->plan->targetlist,
568  varno,
569  inputDesc))
570  {
571  planstate->ps_ProjInfo = NULL;
572  planstate->resultopsset = planstate->scanopsset;
573  planstate->resultopsfixed = planstate->scanopsfixed;
574  planstate->resultops = planstate->scanops;
575  }
576  else
577  {
578  if (!planstate->ps_ResultTupleSlot)
579  {
580  ExecInitResultSlot(planstate, &TTSOpsVirtual);
581  planstate->resultops = &TTSOpsVirtual;
582  planstate->resultopsfixed = true;
583  planstate->resultopsset = true;
584  }
585  ExecAssignProjectionInfo(planstate, inputDesc);
586  }
587 }
588 
589 static bool
590 tlist_matches_tupdesc(PlanState *ps, List *tlist, int varno, TupleDesc tupdesc)
591 {
592  int numattrs = tupdesc->natts;
593  int attrno;
594  ListCell *tlist_item = list_head(tlist);
595 
596  /* Check the tlist attributes */
597  for (attrno = 1; attrno <= numattrs; attrno++)
598  {
599  Form_pg_attribute att_tup = TupleDescAttr(tupdesc, attrno - 1);
600  Var *var;
601 
602  if (tlist_item == NULL)
603  return false; /* tlist too short */
604  var = (Var *) ((TargetEntry *) lfirst(tlist_item))->expr;
605  if (!var || !IsA(var, Var))
606  return false; /* tlist item not a Var */
607  /* if these Asserts fail, planner messed up */
608  Assert(var->varno == varno);
609  Assert(var->varlevelsup == 0);
610  if (var->varattno != attrno)
611  return false; /* out of order */
612  if (att_tup->attisdropped)
613  return false; /* table contains dropped columns */
614  if (att_tup->atthasmissing)
615  return false; /* table contains cols with missing values */
616 
617  /*
618  * Note: usually the Var's type should match the tupdesc exactly, but
619  * in situations involving unions of columns that have different
620  * typmods, the Var may have come from above the union and hence have
621  * typmod -1. This is a legitimate situation since the Var still
622  * describes the column, just not as exactly as the tupdesc does. We
623  * could change the planner to prevent it, but it'd then insert
624  * projection steps just to convert from specific typmod to typmod -1,
625  * which is pretty silly.
626  */
627  if (var->vartype != att_tup->atttypid ||
628  (var->vartypmod != att_tup->atttypmod &&
629  var->vartypmod != -1))
630  return false; /* type mismatch */
631 
632  tlist_item = lnext(tlist, tlist_item);
633  }
634 
635  if (tlist_item)
636  return false; /* tlist too long */
637 
638  return true;
639 }
640 
641 /* ----------------
642  * ExecFreeExprContext
643  *
644  * A plan node's ExprContext should be freed explicitly during executor
645  * shutdown because there may be shutdown callbacks to call. (Other resources
646  * made by the above routines, such as projection info, don't need to be freed
647  * explicitly because they're just memory in the per-query memory context.)
648  *
649  * However ... there is no particular need to do it during ExecEndNode,
650  * because FreeExecutorState will free any remaining ExprContexts within
651  * the EState. Letting FreeExecutorState do it allows the ExprContexts to
652  * be freed in reverse order of creation, rather than order of creation as
653  * will happen if we delete them here, which saves O(N^2) work in the list
654  * cleanup inside FreeExprContext.
655  * ----------------
656  */
657 void
659 {
660  /*
661  * Per above discussion, don't actually delete the ExprContext. We do
662  * unlink it from the plan node, though.
663  */
664  planstate->ps_ExprContext = NULL;
665 }
666 
667 
668 /* ----------------------------------------------------------------
669  * Scan node support
670  * ----------------------------------------------------------------
671  */
672 
673 /* ----------------
674  * ExecAssignScanType
675  * ----------------
676  */
677 void
679 {
680  TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
681 
682  ExecSetSlotDescriptor(slot, tupDesc);
683 }
684 
685 /* ----------------
686  * ExecCreateScanSlotFromOuterPlan
687  * ----------------
688  */
689 void
691  ScanState *scanstate,
692  const TupleTableSlotOps *tts_ops)
693 {
695  TupleDesc tupDesc;
696 
697  outerPlan = outerPlanState(scanstate);
698  tupDesc = ExecGetResultType(outerPlan);
699 
700  ExecInitScanTupleSlot(estate, scanstate, tupDesc, tts_ops);
701 }
702 
703 /* ----------------------------------------------------------------
704  * ExecRelationIsTargetRelation
705  *
706  * Detect whether a relation (identified by rangetable index)
707  * is one of the target relations of the query.
708  *
709  * Note: This is currently no longer used in core. We keep it around
710  * because FDWs may wish to use it to determine if their foreign table
711  * is a target relation.
712  * ----------------------------------------------------------------
713  */
714 bool
716 {
717  return list_member_int(estate->es_plannedstmt->resultRelations, scanrelid);
718 }
719 
720 /* ----------------------------------------------------------------
721  * ExecOpenScanRelation
722  *
723  * Open the heap relation to be scanned by a base-level scan plan node.
724  * This should be called during the node's ExecInit routine.
725  * ----------------------------------------------------------------
726  */
727 Relation
728 ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
729 {
730  Relation rel;
731 
732  /* Open the relation. */
733  rel = ExecGetRangeTableRelation(estate, scanrelid);
734 
735  /*
736  * Complain if we're attempting a scan of an unscannable relation, except
737  * when the query won't actually be run. This is a slightly klugy place
738  * to do this, perhaps, but there is no better place.
739  */
740  if ((eflags & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA)) == 0 &&
741  !RelationIsScannable(rel))
742  ereport(ERROR,
743  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
744  errmsg("materialized view \"%s\" has not been populated",
746  errhint("Use the REFRESH MATERIALIZED VIEW command.")));
747 
748  return rel;
749 }
750 
751 /*
752  * ExecInitRangeTable
753  * Set up executor's range-table-related data
754  *
755  * In addition to the range table proper, initialize arrays that are
756  * indexed by rangetable index.
757  */
758 void
759 ExecInitRangeTable(EState *estate, List *rangeTable, List *permInfos)
760 {
761  /* Remember the range table List as-is */
762  estate->es_range_table = rangeTable;
763 
764  /* ... and the RTEPermissionInfo List too */
765  estate->es_rteperminfos = permInfos;
766 
767  /* Set size of associated arrays */
768  estate->es_range_table_size = list_length(rangeTable);
769 
770  /*
771  * Allocate an array to store an open Relation corresponding to each
772  * rangetable entry, and initialize entries to NULL. Relations are opened
773  * and stored here as needed.
774  */
775  estate->es_relations = (Relation *)
776  palloc0(estate->es_range_table_size * sizeof(Relation));
777 
778  /*
779  * es_result_relations and es_rowmarks are also parallel to
780  * es_range_table, but are allocated only if needed.
781  */
782  estate->es_result_relations = NULL;
783  estate->es_rowmarks = NULL;
784 }
785 
786 /*
787  * ExecGetRangeTableRelation
788  * Open the Relation for a range table entry, if not already done
789  *
790  * The Relations will be closed again in ExecEndPlan().
791  */
792 Relation
794 {
795  Relation rel;
796 
797  Assert(rti > 0 && rti <= estate->es_range_table_size);
798 
799  rel = estate->es_relations[rti - 1];
800  if (rel == NULL)
801  {
802  /* First time through, so open the relation */
803  RangeTblEntry *rte = exec_rt_fetch(rti, estate);
804 
805  Assert(rte->rtekind == RTE_RELATION);
806 
807  if (!IsParallelWorker())
808  {
809  /*
810  * In a normal query, we should already have the appropriate lock,
811  * but verify that through an Assert. Since there's already an
812  * Assert inside table_open that insists on holding some lock, it
813  * seems sufficient to check this only when rellockmode is higher
814  * than the minimum.
815  */
816  rel = table_open(rte->relid, NoLock);
818  CheckRelationLockedByMe(rel, rte->rellockmode, false));
819  }
820  else
821  {
822  /*
823  * If we are a parallel worker, we need to obtain our own local
824  * lock on the relation. This ensures sane behavior in case the
825  * parent process exits before we do.
826  */
827  rel = table_open(rte->relid, rte->rellockmode);
828  }
829 
830  estate->es_relations[rti - 1] = rel;
831  }
832 
833  return rel;
834 }
835 
836 /*
837  * ExecInitResultRelation
838  * Open relation given by the passed-in RT index and fill its
839  * ResultRelInfo node
840  *
841  * Here, we also save the ResultRelInfo in estate->es_result_relations array
842  * such that it can be accessed later using the RT index.
843  */
844 void
846  Index rti)
847 {
848  Relation resultRelationDesc;
849 
850  resultRelationDesc = ExecGetRangeTableRelation(estate, rti);
851  InitResultRelInfo(resultRelInfo,
852  resultRelationDesc,
853  rti,
854  NULL,
855  estate->es_instrument);
856 
857  if (estate->es_result_relations == NULL)
858  estate->es_result_relations = (ResultRelInfo **)
859  palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *));
860  estate->es_result_relations[rti - 1] = resultRelInfo;
861 
862  /*
863  * Saving in the list allows to avoid needlessly traversing the whole
864  * array when only a few of its entries are possibly non-NULL.
865  */
867  lappend(estate->es_opened_result_relations, resultRelInfo);
868 }
869 
870 /*
871  * UpdateChangedParamSet
872  * Add changed parameters to a plan node's chgParam set
873  */
874 void
876 {
877  Bitmapset *parmset;
878 
879  /*
880  * The plan node only depends on params listed in its allParam set. Don't
881  * include anything else into its chgParam set.
882  */
883  parmset = bms_intersect(node->plan->allParam, newchg);
884  node->chgParam = bms_join(node->chgParam, parmset);
885 }
886 
887 /*
888  * executor_errposition
889  * Report an execution-time cursor position, if possible.
890  *
891  * This is expected to be used within an ereport() call. The return value
892  * is a dummy (always 0, in fact).
893  *
894  * The locations stored in parsetrees are byte offsets into the source string.
895  * We have to convert them to 1-based character indexes for reporting to
896  * clients. (We do things this way to avoid unnecessary overhead in the
897  * normal non-error case: computing character indexes would be much more
898  * expensive than storing token offsets.)
899  */
900 int
901 executor_errposition(EState *estate, int location)
902 {
903  int pos;
904 
905  /* No-op if location was not provided */
906  if (location < 0)
907  return 0;
908  /* Can't do anything if source text is not available */
909  if (estate == NULL || estate->es_sourceText == NULL)
910  return 0;
911  /* Convert offset to character number */
912  pos = pg_mbstrlen_with_len(estate->es_sourceText, location) + 1;
913  /* And pass it to the ereport mechanism */
914  return errposition(pos);
915 }
916 
917 /*
918  * Register a shutdown callback in an ExprContext.
919  *
920  * Shutdown callbacks will be called (in reverse order of registration)
921  * when the ExprContext is deleted or rescanned. This provides a hook
922  * for functions called in the context to do any cleanup needed --- it's
923  * particularly useful for functions returning sets. Note that the
924  * callback will *not* be called in the event that execution is aborted
925  * by an error.
926  */
927 void
930  Datum arg)
931 {
932  ExprContext_CB *ecxt_callback;
933 
934  /* Save the info in appropriate memory context */
935  ecxt_callback = (ExprContext_CB *)
937  sizeof(ExprContext_CB));
938 
939  ecxt_callback->function = function;
940  ecxt_callback->arg = arg;
941 
942  /* link to front of list for appropriate execution order */
943  ecxt_callback->next = econtext->ecxt_callbacks;
944  econtext->ecxt_callbacks = ecxt_callback;
945 }
946 
947 /*
948  * Deregister a shutdown callback in an ExprContext.
949  *
950  * Any list entries matching the function and arg will be removed.
951  * This can be used if it's no longer necessary to call the callback.
952  */
953 void
956  Datum arg)
957 {
958  ExprContext_CB **prev_callback;
959  ExprContext_CB *ecxt_callback;
960 
961  prev_callback = &econtext->ecxt_callbacks;
962 
963  while ((ecxt_callback = *prev_callback) != NULL)
964  {
965  if (ecxt_callback->function == function && ecxt_callback->arg == arg)
966  {
967  *prev_callback = ecxt_callback->next;
968  pfree(ecxt_callback);
969  }
970  else
971  prev_callback = &ecxt_callback->next;
972  }
973 }
974 
975 /*
976  * Call all the shutdown callbacks registered in an ExprContext.
977  *
978  * The callback list is emptied (important in case this is only a rescan
979  * reset, and not deletion of the ExprContext).
980  *
981  * If isCommit is false, just clean the callback list but don't call 'em.
982  * (See comment for FreeExprContext.)
983  */
984 static void
985 ShutdownExprContext(ExprContext *econtext, bool isCommit)
986 {
987  ExprContext_CB *ecxt_callback;
988  MemoryContext oldcontext;
989 
990  /* Fast path in normal case where there's nothing to do. */
991  if (econtext->ecxt_callbacks == NULL)
992  return;
993 
994  /*
995  * Call the callbacks in econtext's per-tuple context. This ensures that
996  * any memory they might leak will get cleaned up.
997  */
998  oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
999 
1000  /*
1001  * Call each callback function in reverse registration order.
1002  */
1003  while ((ecxt_callback = econtext->ecxt_callbacks) != NULL)
1004  {
1005  econtext->ecxt_callbacks = ecxt_callback->next;
1006  if (isCommit)
1007  ecxt_callback->function(ecxt_callback->arg);
1008  pfree(ecxt_callback);
1009  }
1010 
1011  MemoryContextSwitchTo(oldcontext);
1012 }
1013 
1014 /*
1015  * GetAttributeByName
1016  * GetAttributeByNum
1017  *
1018  * These functions return the value of the requested attribute
1019  * out of the given tuple Datum.
1020  * C functions which take a tuple as an argument are expected
1021  * to use these. Ex: overpaid(EMP) might call GetAttributeByNum().
1022  * Note: these are actually rather slow because they do a typcache
1023  * lookup on each call.
1024  */
1025 Datum
1026 GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
1027 {
1028  AttrNumber attrno;
1029  Datum result;
1030  Oid tupType;
1031  int32 tupTypmod;
1032  TupleDesc tupDesc;
1033  HeapTupleData tmptup;
1034  int i;
1035 
1036  if (attname == NULL)
1037  elog(ERROR, "invalid attribute name");
1038 
1039  if (isNull == NULL)
1040  elog(ERROR, "a NULL isNull pointer was passed");
1041 
1042  if (tuple == NULL)
1043  {
1044  /* Kinda bogus but compatible with old behavior... */
1045  *isNull = true;
1046  return (Datum) 0;
1047  }
1048 
1049  tupType = HeapTupleHeaderGetTypeId(tuple);
1050  tupTypmod = HeapTupleHeaderGetTypMod(tuple);
1051  tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1052 
1053  attrno = InvalidAttrNumber;
1054  for (i = 0; i < tupDesc->natts; i++)
1055  {
1056  Form_pg_attribute att = TupleDescAttr(tupDesc, i);
1057 
1058  if (namestrcmp(&(att->attname), attname) == 0)
1059  {
1060  attrno = att->attnum;
1061  break;
1062  }
1063  }
1064 
1065  if (attrno == InvalidAttrNumber)
1066  elog(ERROR, "attribute \"%s\" does not exist", attname);
1067 
1068  /*
1069  * heap_getattr needs a HeapTuple not a bare HeapTupleHeader. We set all
1070  * the fields in the struct just in case user tries to inspect system
1071  * columns.
1072  */
1073  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
1074  ItemPointerSetInvalid(&(tmptup.t_self));
1075  tmptup.t_tableOid = InvalidOid;
1076  tmptup.t_data = tuple;
1077 
1078  result = heap_getattr(&tmptup,
1079  attrno,
1080  tupDesc,
1081  isNull);
1082 
1083  ReleaseTupleDesc(tupDesc);
1084 
1085  return result;
1086 }
1087 
1088 Datum
1090  AttrNumber attrno,
1091  bool *isNull)
1092 {
1093  Datum result;
1094  Oid tupType;
1095  int32 tupTypmod;
1096  TupleDesc tupDesc;
1097  HeapTupleData tmptup;
1098 
1099  if (!AttributeNumberIsValid(attrno))
1100  elog(ERROR, "invalid attribute number %d", attrno);
1101 
1102  if (isNull == NULL)
1103  elog(ERROR, "a NULL isNull pointer was passed");
1104 
1105  if (tuple == NULL)
1106  {
1107  /* Kinda bogus but compatible with old behavior... */
1108  *isNull = true;
1109  return (Datum) 0;
1110  }
1111 
1112  tupType = HeapTupleHeaderGetTypeId(tuple);
1113  tupTypmod = HeapTupleHeaderGetTypMod(tuple);
1114  tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
1115 
1116  /*
1117  * heap_getattr needs a HeapTuple not a bare HeapTupleHeader. We set all
1118  * the fields in the struct just in case user tries to inspect system
1119  * columns.
1120  */
1121  tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
1122  ItemPointerSetInvalid(&(tmptup.t_self));
1123  tmptup.t_tableOid = InvalidOid;
1124  tmptup.t_data = tuple;
1125 
1126  result = heap_getattr(&tmptup,
1127  attrno,
1128  tupDesc,
1129  isNull);
1130 
1131  ReleaseTupleDesc(tupDesc);
1132 
1133  return result;
1134 }
1135 
1136 /*
1137  * Number of items in a tlist (including any resjunk items!)
1138  */
1139 int
1141 {
1142  /* This used to be more complex, but fjoins are dead */
1143  return list_length(targetlist);
1144 }
1145 
1146 /*
1147  * Number of items in a tlist, not including any resjunk items
1148  */
1149 int
1151 {
1152  int len = 0;
1153  ListCell *tl;
1154 
1155  foreach(tl, targetlist)
1156  {
1157  TargetEntry *curTle = lfirst_node(TargetEntry, tl);
1158 
1159  if (!curTle->resjunk)
1160  len++;
1161  }
1162  return len;
1163 }
1164 
1165 /*
1166  * Return a relInfo's tuple slot for a trigger's OLD tuples.
1167  */
1170 {
1171  if (relInfo->ri_TrigOldSlot == NULL)
1172  {
1173  Relation rel = relInfo->ri_RelationDesc;
1174  MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1175 
1176  relInfo->ri_TrigOldSlot =
1177  ExecInitExtraTupleSlot(estate,
1178  RelationGetDescr(rel),
1179  table_slot_callbacks(rel));
1180 
1181  MemoryContextSwitchTo(oldcontext);
1182  }
1183 
1184  return relInfo->ri_TrigOldSlot;
1185 }
1186 
1187 /*
1188  * Return a relInfo's tuple slot for a trigger's NEW tuples.
1189  */
1192 {
1193  if (relInfo->ri_TrigNewSlot == NULL)
1194  {
1195  Relation rel = relInfo->ri_RelationDesc;
1196  MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1197 
1198  relInfo->ri_TrigNewSlot =
1199  ExecInitExtraTupleSlot(estate,
1200  RelationGetDescr(rel),
1201  table_slot_callbacks(rel));
1202 
1203  MemoryContextSwitchTo(oldcontext);
1204  }
1205 
1206  return relInfo->ri_TrigNewSlot;
1207 }
1208 
1209 /*
1210  * Return a relInfo's tuple slot for processing returning tuples.
1211  */
1214 {
1215  if (relInfo->ri_ReturningSlot == NULL)
1216  {
1217  Relation rel = relInfo->ri_RelationDesc;
1218  MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1219 
1220  relInfo->ri_ReturningSlot =
1221  ExecInitExtraTupleSlot(estate,
1222  RelationGetDescr(rel),
1223  table_slot_callbacks(rel));
1224 
1225  MemoryContextSwitchTo(oldcontext);
1226  }
1227 
1228  return relInfo->ri_ReturningSlot;
1229 }
1230 
1231 /*
1232  * Return the map needed to convert given child result relation's tuples to
1233  * the rowtype of the query's main target ("root") relation. Note that a
1234  * NULL result is valid and means that no conversion is needed.
1235  */
1238 {
1239  /* If we didn't already do so, compute the map for this child. */
1240  if (!resultRelInfo->ri_ChildToRootMapValid)
1241  {
1242  ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1243 
1244  if (rootRelInfo)
1245  resultRelInfo->ri_ChildToRootMap =
1247  RelationGetDescr(rootRelInfo->ri_RelationDesc));
1248  else /* this isn't a child result rel */
1249  resultRelInfo->ri_ChildToRootMap = NULL;
1250 
1251  resultRelInfo->ri_ChildToRootMapValid = true;
1252  }
1253 
1254  return resultRelInfo->ri_ChildToRootMap;
1255 }
1256 
1257 /*
1258  * Returns the map needed to convert given root result relation's tuples to
1259  * the rowtype of the given child relation. Note that a NULL result is valid
1260  * and means that no conversion is needed.
1261  */
1264 {
1265  /* Mustn't get called for a non-child result relation. */
1266  Assert(resultRelInfo->ri_RootResultRelInfo);
1267 
1268  /* If we didn't already do so, compute the map for this child. */
1269  if (!resultRelInfo->ri_RootToChildMapValid)
1270  {
1271  ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
1272  TupleDesc indesc = RelationGetDescr(rootRelInfo->ri_RelationDesc);
1273  TupleDesc outdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
1274  Relation childrel = resultRelInfo->ri_RelationDesc;
1275  AttrMap *attrMap;
1276  MemoryContext oldcontext;
1277 
1278  /*
1279  * When this child table is not a partition (!relispartition), it may
1280  * have columns that are not present in the root table, which we ask
1281  * to ignore by passing true for missing_ok.
1282  */
1283  oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
1284  attrMap = build_attrmap_by_name_if_req(indesc, outdesc,
1285  !childrel->rd_rel->relispartition);
1286  if (attrMap)
1287  resultRelInfo->ri_RootToChildMap =
1288  convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
1289  MemoryContextSwitchTo(oldcontext);
1290  resultRelInfo->ri_RootToChildMapValid = true;
1291  }
1292 
1293  return resultRelInfo->ri_RootToChildMap;
1294 }
1295 
1296 /* Return a bitmap representing columns being inserted */
1297 Bitmapset *
1299 {
1300  RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
1301 
1302  if (perminfo == NULL)
1303  return NULL;
1304 
1305  /* Map the columns to child's attribute numbers if needed. */
1306  if (relinfo->ri_RootResultRelInfo)
1307  {
1308  TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
1309 
1310  if (map)
1311  return execute_attr_map_cols(map->attrMap, perminfo->insertedCols);
1312  }
1313 
1314  return perminfo->insertedCols;
1315 }
1316 
1317 /* Return a bitmap representing columns being updated */
1318 Bitmapset *
1320 {
1321  RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
1322 
1323  if (perminfo == NULL)
1324  return NULL;
1325 
1326  /* Map the columns to child's attribute numbers if needed. */
1327  if (relinfo->ri_RootResultRelInfo)
1328  {
1329  TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
1330 
1331  if (map)
1332  return execute_attr_map_cols(map->attrMap, perminfo->updatedCols);
1333  }
1334 
1335  return perminfo->updatedCols;
1336 }
1337 
1338 /* Return a bitmap representing generated columns being updated */
1339 Bitmapset *
1341 {
1342  /* Compute the info if we didn't already */
1343  if (relinfo->ri_GeneratedExprsU == NULL)
1344  ExecInitStoredGenerated(relinfo, estate, CMD_UPDATE);
1345  return relinfo->ri_extraUpdatedCols;
1346 }
1347 
1348 /* Return columns being updated, including generated columns */
1349 Bitmapset *
1351 {
1352  return bms_union(ExecGetUpdatedCols(relinfo, estate),
1353  ExecGetExtraUpdatedCols(relinfo, estate));
1354 }
1355 
1356 /*
1357  * GetResultRTEPermissionInfo
1358  * Looks up RTEPermissionInfo for ExecGet*Cols() routines
1359  */
1360 static RTEPermissionInfo *
1362 {
1363  Index rti;
1364  RangeTblEntry *rte;
1365  RTEPermissionInfo *perminfo = NULL;
1366 
1367  if (relinfo->ri_RootResultRelInfo)
1368  {
1369  /*
1370  * For inheritance child result relations (a partition routing target
1371  * of an INSERT or a child UPDATE target), this returns the root
1372  * parent's RTE to fetch the RTEPermissionInfo because that's the only
1373  * one that has one assigned.
1374  */
1375  rti = relinfo->ri_RootResultRelInfo->ri_RangeTableIndex;
1376  }
1377  else if (relinfo->ri_RangeTableIndex != 0)
1378  {
1379  /*
1380  * Non-child result relation should have their own RTEPermissionInfo.
1381  */
1382  rti = relinfo->ri_RangeTableIndex;
1383  }
1384  else
1385  {
1386  /*
1387  * The relation isn't in the range table and it isn't a partition
1388  * routing target. This ResultRelInfo must've been created only for
1389  * firing triggers and the relation is not being inserted into. (See
1390  * ExecGetTriggerResultRel.)
1391  */
1392  rti = 0;
1393  }
1394 
1395  if (rti > 0)
1396  {
1397  rte = exec_rt_fetch(rti, estate);
1398  perminfo = getRTEPermissionInfo(estate->es_rteperminfos, rte);
1399  }
1400 
1401  return perminfo;
1402 }
1403 
1404 /*
1405  * GetResultRelCheckAsUser
1406  * Returns the user to modify passed-in result relation as
1407  *
1408  * The user is chosen by looking up the relation's or, if a child table, its
1409  * root parent's RTEPermissionInfo.
1410  */
1411 Oid
1413 {
1414  RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relInfo, estate);
1415 
1416  /* XXX - maybe ok to return GetUserId() in this case? */
1417  if (perminfo == NULL)
1418  elog(ERROR, "no RTEPermissionInfo found for result relation with OID %u",
1419  RelationGetRelid(relInfo->ri_RelationDesc));
1420 
1421  return perminfo->checkAsUser ? perminfo->checkAsUser : GetUserId();
1422 }
AttrMap * build_attrmap_by_name_if_req(TupleDesc indesc, TupleDesc outdesc, bool missing_ok)
Definition: attmap.c:264
int16 AttrNumber
Definition: attnum.h:21
#define AttributeNumberIsValid(attributeNumber)
Definition: attnum.h:34
#define InvalidAttrNumber
Definition: attnum.h:23
Bitmapset * bms_join(Bitmapset *a, Bitmapset *b)
Definition: bitmapset.c:987
Bitmapset * bms_union(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:226
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:260
signed int int32
Definition: c.h:478
unsigned int Index
Definition: c.h:598
uint32 CommandId
Definition: c.h:650
size_t Size
Definition: c.h:589
int errhint(const char *fmt,...)
Definition: elog.c:1316
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
int errposition(int cursorpos)
Definition: elog.c:1445
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
ProjectionInfo * ExecBuildProjectionInfo(List *targetList, ExprContext *econtext, TupleTableSlot *slot, PlanState *parent, TupleDesc inputDesc)
Definition: execExpr.c:357
void InitResultRelInfo(ResultRelInfo *resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo *partition_root_rri, int instrument_options)
Definition: execMain.c:1188
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:83
void ExecInitResultSlot(PlanState *planstate, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1779
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1811
TupleTableSlot * ExecInitExtraTupleSlot(EState *estate, TupleDesc tupledesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1831
void ExecSetSlotDescriptor(TupleTableSlot *slot, TupleDesc tupdesc)
Definition: execTuples.c:1289
TupleDesc ExecGetResultType(PlanState *planstate)
Definition: execUtils.c:498
Bitmapset * ExecGetAllUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1350
static void ShutdownExprContext(ExprContext *econtext, bool isCommit)
Definition: execUtils.c:985
TupleTableSlot * ExecGetTriggerOldSlot(EState *estate, ResultRelInfo *relInfo)
Definition: execUtils.c:1169
void ReScanExprContext(ExprContext *econtext)
Definition: execUtils.c:446
ExprContext * CreateWorkExprContext(EState *estate)
Definition: execUtils.c:324
const TupleTableSlotOps * ExecGetResultSlotOps(PlanState *planstate, bool *isfixed)
Definition: execUtils.c:507
Bitmapset * ExecGetUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1319
static RTEPermissionInfo * GetResultRTEPermissionInfo(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1361
void ExecInitRangeTable(EState *estate, List *rangeTable, List *permInfos)
Definition: execUtils.c:759
TupleTableSlot * ExecGetReturningSlot(EState *estate, ResultRelInfo *relInfo)
Definition: execUtils.c:1213
int executor_errposition(EState *estate, int location)
Definition: execUtils.c:901
Datum GetAttributeByNum(HeapTupleHeader tuple, AttrNumber attrno, bool *isNull)
Definition: execUtils.c:1089
void FreeExprContext(ExprContext *econtext, bool isCommit)
Definition: execUtils.c:419
static bool tlist_matches_tupdesc(PlanState *ps, List *tlist, int varno, TupleDesc tupdesc)
Definition: execUtils.c:590
void ExecInitResultRelation(EState *estate, ResultRelInfo *resultRelInfo, Index rti)
Definition: execUtils.c:845
ExprContext * CreateStandaloneExprContext(void)
Definition: execUtils.c:360
void ExecCreateScanSlotFromOuterPlan(EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)
Definition: execUtils.c:690
EState * CreateExecutorState(void)
Definition: execUtils.c:93
ExprContext * CreateExprContext(EState *estate)
Definition: execUtils.c:309
TupleTableSlot * ExecGetTriggerNewSlot(EState *estate, ResultRelInfo *relInfo)
Definition: execUtils.c:1191
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:488
Relation ExecGetRangeTableRelation(EState *estate, Index rti)
Definition: execUtils.c:793
void ExecAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc)
Definition: execUtils.c:543
void UnregisterExprContextCallback(ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
Definition: execUtils.c:954
void ExecAssignScanType(ScanState *scanstate, TupleDesc tupDesc)
Definition: execUtils.c:678
void ExecConditionalAssignProjectionInfo(PlanState *planstate, TupleDesc inputDesc, int varno)
Definition: execUtils.c:563
void RegisterExprContextCallback(ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
Definition: execUtils.c:928
TupleConversionMap * ExecGetRootToChildMap(ResultRelInfo *resultRelInfo, EState *estate)
Definition: execUtils.c:1263
int ExecTargetListLength(List *targetlist)
Definition: execUtils.c:1140
void FreeExecutorState(EState *estate)
Definition: execUtils.c:194
bool ExecRelationIsTargetRelation(EState *estate, Index scanrelid)
Definition: execUtils.c:715
TupleConversionMap * ExecGetChildToRootMap(ResultRelInfo *resultRelInfo)
Definition: execUtils.c:1237
int ExecCleanTargetListLength(List *targetlist)
Definition: execUtils.c:1150
void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
Definition: execUtils.c:875
Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname, bool *isNull)
Definition: execUtils.c:1026
ExprContext * MakePerTupleExprContext(EState *estate)
Definition: execUtils.c:461
Bitmapset * ExecGetExtraUpdatedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1340
static ExprContext * CreateExprContextInternal(EState *estate, Size minContextSize, Size initBlockSize, Size maxBlockSize)
Definition: execUtils.c:239
Bitmapset * ExecGetInsertedCols(ResultRelInfo *relinfo, EState *estate)
Definition: execUtils.c:1298
Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
Definition: execUtils.c:728
Oid ExecGetResultRelCheckAsUser(ResultRelInfo *relInfo, EState *estate)
Definition: execUtils.c:1412
void ExecFreeExprContext(PlanState *planstate)
Definition: execUtils.c:658
void(* ExprContextCallbackFunction)(Datum arg)
Definition: execnodes.h:211
#define outerPlanState(node)
Definition: execnodes.h:1131
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition: executor.h:586
#define EXEC_FLAG_WITH_NO_DATA
Definition: executor.h:71
#define EXEC_FLAG_EXPLAIN_ONLY
Definition: executor.h:65
int work_mem
Definition: globals.c:125
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
#define IsParallelWorker()
Definition: parallel.h:61
struct parser_state ps
int i
Definition: isn.c:73
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
void jit_release_context(JitContext *context)
Definition: jit.c:138
Assert(fmt[strlen(fmt) - 1] !='\n')
List * list_delete_ptr(List *list, void *datum)
Definition: list.c:871
List * lappend(List *list, void *datum)
Definition: list.c:338
bool list_member_int(const List *list, int datum)
Definition: list.c:701
List * lcons(void *datum, List *list)
Definition: list.c:494
bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode, bool orstronger)
Definition: lmgr.c:331
#define NoLock
Definition: lockdefs.h:34
#define AccessShareLock
Definition: lockdefs.h:36
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:1058
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:314
void pfree(void *pointer)
Definition: mcxt.c:1436
void * palloc0(Size size)
Definition: mcxt.c:1241
MemoryContext CurrentMemoryContext
Definition: mcxt.c:135
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1005
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:387
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_MAXSIZE
Definition: memutils.h:152
#define ALLOCSET_DEFAULT_MINSIZE
Definition: memutils.h:150
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:153
#define ALLOCSET_DEFAULT_INITSIZE
Definition: memutils.h:151
Oid GetUserId(void)
Definition: miscinit.c:510
int namestrcmp(Name name, const char *str)
Definition: name.c:247
void ExecInitStoredGenerated(ResultRelInfo *resultRelInfo, EState *estate, CmdType cmdtype)
#define IsA(nodeptr, _type_)
Definition: nodes.h:179
@ CMD_UPDATE
Definition: nodes.h:277
#define makeNode(_type_)
Definition: nodes.h:176
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:138
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
@ RTE_RELATION
Definition: parsenodes.h:1014
void DestroyPartitionDirectory(PartitionDirectory pdir)
Definition: partdesc.c:444
NameData attname
Definition: pg_attribute.h:41
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
void * arg
const void size_t len
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
#define linitial(l)
Definition: pg_list.h:178
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
#define outerPlan(node)
Definition: plannodes.h:186
uintptr_t Datum
Definition: postgres.h:64
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define RelationGetRelid(relation)
Definition: rel.h:503
#define RelationIsScannable(relation)
Definition: rel.h:669
#define RelationGetDescr(relation)
Definition: rel.h:529
#define RelationGetRelationName(relation)
Definition: rel.h:537
@ ForwardScanDirection
Definition: sdir.h:28
#define InvalidSnapshot
Definition: snapshot.h:123
Definition: attmap.h:35
uint64 es_processed
Definition: execnodes.h:664
List * es_part_prune_infos
Definition: execnodes.h:626
struct ExecRowMark ** es_rowmarks
Definition: execnodes.h:622
List * es_tuple_routing_result_relations
Definition: execnodes.h:648
int es_top_eflags
Definition: execnodes.h:666
struct JitContext * es_jit
Definition: execnodes.h:706
int es_instrument
Definition: execnodes.h:667
PlannedStmt * es_plannedstmt
Definition: execnodes.h:625
QueryEnvironment * es_queryEnv
Definition: execnodes.h:657
ResultRelInfo ** es_result_relations
Definition: execnodes.h:635
ParamExecData * es_param_exec_vals
Definition: execnodes.h:655
List * es_range_table
Definition: execnodes.h:618
List * es_rteperminfos
Definition: execnodes.h:624
List * es_exprcontexts
Definition: execnodes.h:670
ParamListInfo es_param_list_info
Definition: execnodes.h:654
bool es_finished
Definition: execnodes.h:668
List * es_insert_pending_result_relations
Definition: execnodes.h:713
MemoryContext es_query_cxt
Definition: execnodes.h:660
List * es_tupleTable
Definition: execnodes.h:662
ScanDirection es_direction
Definition: execnodes.h:615
PartitionDirectory es_partition_directory
Definition: execnodes.h:642
List * es_trig_target_relations
Definition: execnodes.h:651
int es_jit_flags
Definition: execnodes.h:705
List * es_opened_result_relations
Definition: execnodes.h:638
bool es_use_parallel_mode
Definition: execnodes.h:691
Relation * es_relations
Definition: execnodes.h:620
List * es_subplanstates
Definition: execnodes.h:672
ExprContext * es_per_tuple_exprcontext
Definition: execnodes.h:681
CommandId es_output_cid
Definition: execnodes.h:632
Index es_range_table_size
Definition: execnodes.h:619
List * es_insert_pending_modifytables
Definition: execnodes.h:714
const char * es_sourceText
Definition: execnodes.h:627
Snapshot es_snapshot
Definition: execnodes.h:616
List * es_auxmodifytables
Definition: execnodes.h:674
JunkFilter * es_junkFilter
Definition: execnodes.h:629
Snapshot es_crosscheck_snapshot
Definition: execnodes.h:617
struct ExprContext_CB * next
Definition: execnodes.h:215
ExprContextCallbackFunction function
Definition: execnodes.h:216
Datum domainValue_datum
Definition: execnodes.h:280
ParamListInfo ecxt_param_list_info
Definition: execnodes.h:261
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:257
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:251
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:260
Datum * ecxt_aggvalues
Definition: execnodes.h:268
bool caseValue_isNull
Definition: execnodes.h:276
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:249
Datum caseValue_datum
Definition: execnodes.h:274
bool * ecxt_aggnulls
Definition: execnodes.h:270
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:256
ExprContext_CB * ecxt_callbacks
Definition: execnodes.h:288
bool domainValue_isNull
Definition: execnodes.h:282
struct EState * ecxt_estate
Definition: execnodes.h:285
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:253
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
Definition: pg_list.h:54
const TupleTableSlotOps * resultops
Definition: execnodes.h:1112
bool resultopsset
Definition: execnodes.h:1120
const TupleTableSlotOps * scanops
Definition: execnodes.h:1109
Plan * plan
Definition: execnodes.h:1035
TupleDesc ps_ResultTupleDesc
Definition: execnodes.h:1072
Bitmapset * chgParam
Definition: execnodes.h:1067
bool scanopsset
Definition: execnodes.h:1117
ExprContext * ps_ExprContext
Definition: execnodes.h:1074
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:1073
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1075
bool scanopsfixed
Definition: execnodes.h:1113
bool resultopsfixed
Definition: execnodes.h:1116
Bitmapset * allParam
Definition: plannodes.h:175
List * targetlist
Definition: plannodes.h:156
List * resultRelations
Definition: plannodes.h:82
Bitmapset * insertedCols
Definition: parsenodes.h:1249
Bitmapset * updatedCols
Definition: parsenodes.h:1250
RTEKind rtekind
Definition: parsenodes.h:1033
Form_pg_class rd_rel
Definition: rel.h:110
TupleConversionMap * ri_RootToChildMap
Definition: execnodes.h:560
struct ResultRelInfo * ri_RootResultRelInfo
Definition: execnodes.h:574
Relation ri_RelationDesc
Definition: execnodes.h:450
TupleTableSlot * ri_ReturningSlot
Definition: execnodes.h:492
bool ri_RootToChildMapValid
Definition: execnodes.h:561
Bitmapset * ri_extraUpdatedCols
Definition: execnodes.h:468
Index ri_RangeTableIndex
Definition: execnodes.h:447
TupleConversionMap * ri_ChildToRootMap
Definition: execnodes.h:554
bool ri_ChildToRootMapValid
Definition: execnodes.h:555
ExprState ** ri_GeneratedExprsU
Definition: execnodes.h:523
TupleTableSlot * ri_TrigNewSlot
Definition: execnodes.h:494
TupleTableSlot * ri_TrigOldSlot
Definition: execnodes.h:493
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1464
AttrMap * attrMap
Definition: tupconvert.h:28
const TupleTableSlotOps *const tts_ops
Definition: tuptable.h:122
Definition: primnodes.h:226
AttrNumber varattno
Definition: primnodes.h:238
int varno
Definition: primnodes.h:233
Index varlevelsup
Definition: primnodes.h:258
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
Definition: tableam.c:58
Bitmapset * execute_attr_map_cols(AttrMap *attrMap, Bitmapset *in_cols)
Definition: tupconvert.c:252
TupleConversionMap * convert_tuples_by_name_attrmap(TupleDesc indesc, TupleDesc outdesc, AttrMap *attrMap)
Definition: tupconvert.c:124
TupleConversionMap * convert_tuples_by_name(TupleDesc indesc, TupleDesc outdesc)
Definition: tupconvert.c:102
#define ReleaseTupleDesc(tupdesc)
Definition: tupdesc.h:122
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define TTS_FIXED(slot)
Definition: tuptable.h:109
TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
Definition: typcache.c:1824