PostgreSQL Source Code  git master
plannodes.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * plannodes.h
4  * definitions for query plan nodes
5  *
6  *
7  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
8  * Portions Copyright (c) 1994, Regents of the University of California
9  *
10  * src/include/nodes/plannodes.h
11  *
12  *-------------------------------------------------------------------------
13  */
14 #ifndef PLANNODES_H
15 #define PLANNODES_H
16 
17 #include "access/sdir.h"
18 #include "access/stratnum.h"
19 #include "common/relpath.h"
20 #include "lib/stringinfo.h"
21 #include "nodes/bitmapset.h"
22 #include "nodes/lockoptions.h"
23 #include "nodes/primnodes.h"
24 
25 
26 /* ----------------------------------------------------------------
27  * node definitions
28  * ----------------------------------------------------------------
29  */
30 
31 /* ----------------
32  * PlannedStmt node
33  *
34  * The output of the planner is a Plan tree headed by a PlannedStmt node.
35  * PlannedStmt holds the "one time" information needed by the executor.
36  *
37  * For simplicity in APIs, we also wrap utility statements in PlannedStmt
38  * nodes; in such cases, commandType == CMD_UTILITY, the statement itself
39  * is in the utilityStmt field, and the rest of the struct is mostly dummy.
40  * (We do use canSetTag, stmt_location, stmt_len, and possibly queryId.)
41  *
42  * PlannedStmt, as well as all varieties of Plan, do not support equal(),
43  * not because it's not sensible but because we currently have no need.
44  * ----------------
45  */
46 typedef struct PlannedStmt
47 {
48  pg_node_attr(no_equal, no_query_jumble)
49 
50  NodeTag type;
51 
52  CmdType commandType; /* select|insert|update|delete|merge|utility */
53 
54  uint64 queryId; /* query identifier (copied from Query) */
55 
56  bool hasReturning; /* is it insert|update|delete|merge RETURNING? */
57 
58  bool hasModifyingCTE; /* has insert|update|delete|merge in WITH? */
59 
60  bool canSetTag; /* do I set the command result tag? */
61 
62  bool transientPlan; /* redo plan when TransactionXmin changes? */
63 
64  bool dependsOnRole; /* is plan specific to current role? */
65 
66  bool parallelModeNeeded; /* parallel mode required to execute? */
67 
68  int jitFlags; /* which forms of JIT should be performed */
69 
70  struct Plan *planTree; /* tree of Plan nodes */
71 
72  List *rtable; /* list of RangeTblEntry nodes */
73 
74  List *permInfos; /* list of RTEPermissionInfo nodes for rtable
75  * entries needing one */
76 
77  /* rtable indexes of target relations for INSERT/UPDATE/DELETE/MERGE */
78  List *resultRelations; /* integer list of RT indexes, or NIL */
79 
80  List *appendRelations; /* list of AppendRelInfo nodes */
81 
82  List *subplans; /* Plan trees for SubPlan expressions; note
83  * that some could be NULL */
84 
85  Bitmapset *rewindPlanIDs; /* indices of subplans that require REWIND */
86 
87  List *rowMarks; /* a list of PlanRowMark's */
88 
89  List *relationOids; /* OIDs of relations the plan depends on */
90 
91  List *invalItems; /* other dependencies, as PlanInvalItems */
92 
93  List *paramExecTypes; /* type OIDs for PARAM_EXEC Params */
94 
95  Node *utilityStmt; /* non-null if this is utility stmt */
96 
97  /* statement location in source string (copied from Query) */
98  ParseLoc stmt_location; /* start location, or -1 if unknown */
99  ParseLoc stmt_len; /* length in bytes; 0 means "rest of string" */
101 
102 /* macro for fetching the Plan associated with a SubPlan node */
103 #define exec_subplan_get_plan(plannedstmt, subplan) \
104  ((Plan *) list_nth((plannedstmt)->subplans, (subplan)->plan_id - 1))
105 
106 
107 /* ----------------
108  * Plan node
109  *
110  * All plan nodes "derive" from the Plan structure by having the
111  * Plan structure as the first field. This ensures that everything works
112  * when nodes are cast to Plan's. (node pointers are frequently cast to Plan*
113  * when passed around generically in the executor)
114  *
115  * We never actually instantiate any Plan nodes; this is just the common
116  * abstract superclass for all Plan-type nodes.
117  * ----------------
118  */
119 typedef struct Plan
120 {
121  pg_node_attr(abstract, no_equal, no_query_jumble)
122 
123  NodeTag type;
124 
125  /*
126  * estimated execution costs for plan (see costsize.c for more info)
127  */
128  Cost startup_cost; /* cost expended before fetching any tuples */
129  Cost total_cost; /* total cost (assuming all tuples fetched) */
130 
131  /*
132  * planner's estimate of result size of this plan step
133  */
134  Cardinality plan_rows; /* number of rows plan is expected to emit */
135  int plan_width; /* average row width in bytes */
136 
137  /*
138  * information needed for parallel query
139  */
140  bool parallel_aware; /* engage parallel-aware logic? */
141  bool parallel_safe; /* OK to use as part of parallel plan? */
142 
143  /*
144  * information needed for asynchronous execution
145  */
146  bool async_capable; /* engage asynchronous-capable logic? */
147 
148  /*
149  * Common structural data for all Plan types.
150  */
151  int plan_node_id; /* unique across entire final plan tree */
152  List *targetlist; /* target list to be computed at this node */
153  List *qual; /* implicitly-ANDed qual conditions */
154  struct Plan *lefttree; /* input plan tree(s) */
155  struct Plan *righttree;
156  List *initPlan; /* Init Plan nodes (un-correlated expr
157  * subselects) */
158 
159  /*
160  * Information for management of parameter-change-driven rescanning
161  *
162  * extParam includes the paramIDs of all external PARAM_EXEC params
163  * affecting this plan node or its children. setParam params from the
164  * node's initPlans are not included, but their extParams are.
165  *
166  * allParam includes all the extParam paramIDs, plus the IDs of local
167  * params that affect the node (i.e., the setParams of its initplans).
168  * These are _all_ the PARAM_EXEC params that affect this node.
169  */
173 
174 /* ----------------
175  * these are defined to avoid confusion problems with "left"
176  * and "right" and "inner" and "outer". The convention is that
177  * the "left" plan is the "outer" plan and the "right" plan is
178  * the inner plan, but these make the code more readable.
179  * ----------------
180  */
181 #define innerPlan(node) (((Plan *)(node))->righttree)
182 #define outerPlan(node) (((Plan *)(node))->lefttree)
183 
184 
185 /* ----------------
186  * Result node -
187  * If no outer plan, evaluate a variable-free targetlist.
188  * If outer plan, return tuples from outer plan (after a level of
189  * projection as shown by targetlist).
190  *
191  * If resconstantqual isn't NULL, it represents a one-time qualification
192  * test (i.e., one that doesn't depend on any variables from the outer plan,
193  * so needs to be evaluated only once).
194  * ----------------
195  */
196 typedef struct Result
197 {
201 
202 /* ----------------
203  * ProjectSet node -
204  * Apply a projection that includes set-returning functions to the
205  * output tuples of the outer plan.
206  * ----------------
207  */
208 typedef struct ProjectSet
209 {
212 
213 /* ----------------
214  * ModifyTable node -
215  * Apply rows produced by outer plan to result table(s),
216  * by inserting, updating, or deleting.
217  *
218  * If the originally named target table is a partitioned table or inheritance
219  * tree, both nominalRelation and rootRelation contain the RT index of the
220  * partition root or appendrel RTE, which is not otherwise mentioned in the
221  * plan. Otherwise rootRelation is zero. However, nominalRelation will
222  * always be set, as it's the rel that EXPLAIN should claim is the
223  * INSERT/UPDATE/DELETE/MERGE target.
224  *
225  * Note that rowMarks and epqParam are presumed to be valid for all the
226  * table(s); they can't contain any info that varies across tables.
227  * ----------------
228  */
229 typedef struct ModifyTable
230 {
232  CmdType operation; /* INSERT, UPDATE, DELETE, or MERGE */
233  bool canSetTag; /* do we set the command tag/es_processed? */
234  Index nominalRelation; /* Parent RT index for use of EXPLAIN */
235  Index rootRelation; /* Root RT index, if partitioned/inherited */
236  bool partColsUpdated; /* some part key in hierarchy updated? */
237  List *resultRelations; /* integer list of RT indexes */
238  List *updateColnosLists; /* per-target-table update_colnos lists */
239  List *withCheckOptionLists; /* per-target-table WCO lists */
240  List *returningLists; /* per-target-table RETURNING tlists */
241  List *fdwPrivLists; /* per-target-table FDW private data lists */
242  Bitmapset *fdwDirectModifyPlans; /* indices of FDW DM plans */
243  List *rowMarks; /* PlanRowMarks (non-locking only) */
244  int epqParam; /* ID of Param for EvalPlanQual re-eval */
245  OnConflictAction onConflictAction; /* ON CONFLICT action */
246  List *arbiterIndexes; /* List of ON CONFLICT arbiter index OIDs */
247  List *onConflictSet; /* INSERT ON CONFLICT DO UPDATE targetlist */
248  List *onConflictCols; /* target column numbers for onConflictSet */
249  Node *onConflictWhere; /* WHERE for ON CONFLICT UPDATE */
250  Index exclRelRTI; /* RTI of the EXCLUDED pseudo relation */
251  List *exclRelTlist; /* tlist of the EXCLUDED pseudo relation */
252  List *mergeActionLists; /* per-target-table lists of actions for
253  * MERGE */
254  List *mergeJoinConditions; /* per-target-table join conditions
255  * for MERGE */
257 
258 struct PartitionPruneInfo; /* forward reference to struct below */
259 
260 /* ----------------
261  * Append node -
262  * Generate the concatenation of the results of sub-plans.
263  * ----------------
264  */
265 typedef struct Append
266 {
268  Bitmapset *apprelids; /* RTIs of appendrel(s) formed by this node */
270  int nasyncplans; /* # of asynchronous plans */
271 
272  /*
273  * All 'appendplans' preceding this index are non-partial plans. All
274  * 'appendplans' from this index onwards are partial plans.
275  */
277 
278  /* Info for run-time subplan pruning; NULL if we're not doing that */
281 
282 /* ----------------
283  * MergeAppend node -
284  * Merge the results of pre-sorted sub-plans to preserve the ordering.
285  * ----------------
286  */
287 typedef struct MergeAppend
288 {
290 
291  /* RTIs of appendrel(s) formed by this node */
293 
295 
296  /* these fields are just like the sort-key info in struct Sort: */
297 
298  /* number of sort-key columns */
299  int numCols;
300 
301  /* their indexes in the target list */
302  AttrNumber *sortColIdx pg_node_attr(array_size(numCols));
303 
304  /* OIDs of operators to sort them by */
305  Oid *sortOperators pg_node_attr(array_size(numCols));
306 
307  /* OIDs of collations */
308  Oid *collations pg_node_attr(array_size(numCols));
309 
310  /* NULLS FIRST/LAST directions */
311  bool *nullsFirst pg_node_attr(array_size(numCols));
312 
313  /* Info for run-time subplan pruning; NULL if we're not doing that */
316 
317 /* ----------------
318  * RecursiveUnion node -
319  * Generate a recursive union of two subplans.
320  *
321  * The "outer" subplan is always the non-recursive term, and the "inner"
322  * subplan is the recursive term.
323  * ----------------
324  */
325 typedef struct RecursiveUnion
326 {
328 
329  /* ID of Param representing work table */
330  int wtParam;
331 
332  /* Remaining fields are zero/null in UNION ALL case */
333 
334  /* number of columns to check for duplicate-ness */
335  int numCols;
336 
337  /* their indexes in the target list */
338  AttrNumber *dupColIdx pg_node_attr(array_size(numCols));
339 
340  /* equality operators to compare with */
341  Oid *dupOperators pg_node_attr(array_size(numCols));
342  Oid *dupCollations pg_node_attr(array_size(numCols));
343 
344  /* estimated number of groups in input */
345  long numGroups;
347 
348 /* ----------------
349  * BitmapAnd node -
350  * Generate the intersection of the results of sub-plans.
351  *
352  * The subplans must be of types that yield tuple bitmaps. The targetlist
353  * and qual fields of the plan are unused and are always NIL.
354  * ----------------
355  */
356 typedef struct BitmapAnd
357 {
361 
362 /* ----------------
363  * BitmapOr node -
364  * Generate the union of the results of sub-plans.
365  *
366  * The subplans must be of types that yield tuple bitmaps. The targetlist
367  * and qual fields of the plan are unused and are always NIL.
368  * ----------------
369  */
370 typedef struct BitmapOr
371 {
373  bool isshared;
376 
377 /*
378  * ==========
379  * Scan nodes
380  *
381  * Scan is an abstract type that all relation scan plan types inherit from.
382  * ==========
383  */
384 typedef struct Scan
385 {
386  pg_node_attr(abstract)
387 
388  Plan plan;
389  Index scanrelid; /* relid is index into the range table */
391 
392 /* ----------------
393  * sequential scan node
394  * ----------------
395  */
396 typedef struct SeqScan
397 {
400 
401 /* ----------------
402  * table sample scan node
403  * ----------------
404  */
405 typedef struct SampleScan
406 {
408  /* use struct pointer to avoid including parsenodes.h here */
411 
412 /* ----------------
413  * index scan node
414  *
415  * indexqualorig is an implicitly-ANDed list of index qual expressions, each
416  * in the same form it appeared in the query WHERE condition. Each should
417  * be of the form (indexkey OP comparisonval) or (comparisonval OP indexkey).
418  * The indexkey is a Var or expression referencing column(s) of the index's
419  * base table. The comparisonval might be any expression, but it won't use
420  * any columns of the base table. The expressions are ordered by index
421  * column position (but items referencing the same index column can appear
422  * in any order). indexqualorig is used at runtime only if we have to recheck
423  * a lossy indexqual.
424  *
425  * indexqual has the same form, but the expressions have been commuted if
426  * necessary to put the indexkeys on the left, and the indexkeys are replaced
427  * by Var nodes identifying the index columns (their varno is INDEX_VAR and
428  * their varattno is the index column number).
429  *
430  * indexorderbyorig is similarly the original form of any ORDER BY expressions
431  * that are being implemented by the index, while indexorderby is modified to
432  * have index column Vars on the left-hand side. Here, multiple expressions
433  * must appear in exactly the ORDER BY order, and this is not necessarily the
434  * index column order. Only the expressions are provided, not the auxiliary
435  * sort-order information from the ORDER BY SortGroupClauses; it's assumed
436  * that the sort ordering is fully determinable from the top-level operators.
437  * indexorderbyorig is used at runtime to recheck the ordering, if the index
438  * cannot calculate an accurate ordering. It is also needed for EXPLAIN.
439  *
440  * indexorderbyops is a list of the OIDs of the operators used to sort the
441  * ORDER BY expressions. This is used together with indexorderbyorig to
442  * recheck ordering at run time. (Note that indexorderby, indexorderbyorig,
443  * and indexorderbyops are used for amcanorderbyop cases, not amcanorder.)
444  *
445  * indexorderdir specifies the scan ordering, for indexscans on amcanorder
446  * indexes (for other indexes it should be "don't care").
447  * ----------------
448  */
449 typedef struct IndexScan
450 {
452  Oid indexid; /* OID of index to scan */
453  List *indexqual; /* list of index quals (usually OpExprs) */
454  List *indexqualorig; /* the same in original form */
455  List *indexorderby; /* list of index ORDER BY exprs */
456  List *indexorderbyorig; /* the same in original form */
457  List *indexorderbyops; /* OIDs of sort ops for ORDER BY exprs */
458  ScanDirection indexorderdir; /* forward or backward or don't care */
460 
461 /* ----------------
462  * index-only scan node
463  *
464  * IndexOnlyScan is very similar to IndexScan, but it specifies an
465  * index-only scan, in which the data comes from the index not the heap.
466  * Because of this, *all* Vars in the plan node's targetlist, qual, and
467  * index expressions reference index columns and have varno = INDEX_VAR.
468  *
469  * We could almost use indexqual directly against the index's output tuple
470  * when rechecking lossy index operators, but that won't work for quals on
471  * index columns that are not retrievable. Hence, recheckqual is needed
472  * for rechecks: it expresses the same condition as indexqual, but using
473  * only index columns that are retrievable. (We will not generate an
474  * index-only scan if this is not possible. An example is that if an
475  * index has table column "x" in a retrievable index column "ind1", plus
476  * an expression f(x) in a non-retrievable column "ind2", an indexable
477  * query on f(x) will use "ind2" in indexqual and f(ind1) in recheckqual.
478  * Without the "ind1" column, an index-only scan would be disallowed.)
479  *
480  * We don't currently need a recheckable equivalent of indexorderby,
481  * because we don't support lossy operators in index ORDER BY.
482  *
483  * To help EXPLAIN interpret the index Vars for display, we provide
484  * indextlist, which represents the contents of the index as a targetlist
485  * with one TLE per index column. Vars appearing in this list reference
486  * the base table, and this is the only field in the plan node that may
487  * contain such Vars. Also, for the convenience of setrefs.c, TLEs in
488  * indextlist are marked as resjunk if they correspond to columns that
489  * the index AM cannot reconstruct.
490  * ----------------
491  */
492 typedef struct IndexOnlyScan
493 {
495  Oid indexid; /* OID of index to scan */
496  List *indexqual; /* list of index quals (usually OpExprs) */
497  List *recheckqual; /* index quals in recheckable form */
498  List *indexorderby; /* list of index ORDER BY exprs */
499  List *indextlist; /* TargetEntry list describing index's cols */
500  ScanDirection indexorderdir; /* forward or backward or don't care */
502 
503 /* ----------------
504  * bitmap index scan node
505  *
506  * BitmapIndexScan delivers a bitmap of potential tuple locations;
507  * it does not access the heap itself. The bitmap is used by an
508  * ancestor BitmapHeapScan node, possibly after passing through
509  * intermediate BitmapAnd and/or BitmapOr nodes to combine it with
510  * the results of other BitmapIndexScans.
511  *
512  * The fields have the same meanings as for IndexScan, except we don't
513  * store a direction flag because direction is uninteresting.
514  *
515  * In a BitmapIndexScan plan node, the targetlist and qual fields are
516  * not used and are always NIL. The indexqualorig field is unused at
517  * run time too, but is saved for the benefit of EXPLAIN.
518  * ----------------
519  */
520 typedef struct BitmapIndexScan
521 {
523  Oid indexid; /* OID of index to scan */
524  bool isshared; /* Create shared bitmap if set */
525  List *indexqual; /* list of index quals (OpExprs) */
526  List *indexqualorig; /* the same in original form */
528 
529 /* ----------------
530  * bitmap sequential scan node
531  *
532  * This needs a copy of the qual conditions being used by the input index
533  * scans because there are various cases where we need to recheck the quals;
534  * for example, when the bitmap is lossy about the specific rows on a page
535  * that meet the index condition.
536  * ----------------
537  */
538 typedef struct BitmapHeapScan
539 {
541  List *bitmapqualorig; /* index quals, in standard expr form */
543 
544 /* ----------------
545  * tid scan node
546  *
547  * tidquals is an implicitly OR'ed list of qual expressions of the form
548  * "CTID = pseudoconstant", or "CTID = ANY(pseudoconstant_array)",
549  * or a CurrentOfExpr for the relation.
550  * ----------------
551  */
552 typedef struct TidScan
553 {
555  List *tidquals; /* qual(s) involving CTID = something */
557 
558 /* ----------------
559  * tid range scan node
560  *
561  * tidrangequals is an implicitly AND'ed list of qual expressions of the form
562  * "CTID relop pseudoconstant", where relop is one of >,>=,<,<=.
563  * ----------------
564  */
565 typedef struct TidRangeScan
566 {
568  List *tidrangequals; /* qual(s) involving CTID op something */
570 
571 /* ----------------
572  * subquery scan node
573  *
574  * SubqueryScan is for scanning the output of a sub-query in the range table.
575  * We often need an extra plan node above the sub-query's plan to perform
576  * expression evaluations (which we can't push into the sub-query without
577  * risking changing its semantics). Although we are not scanning a physical
578  * relation, we make this a descendant of Scan anyway for code-sharing
579  * purposes.
580  *
581  * SubqueryScanStatus caches the trivial_subqueryscan property of the node.
582  * SUBQUERY_SCAN_UNKNOWN means not yet determined. This is only used during
583  * planning.
584  *
585  * Note: we store the sub-plan in the type-specific subplan field, not in
586  * the generic lefttree field as you might expect. This is because we do
587  * not want plan-tree-traversal routines to recurse into the subplan without
588  * knowing that they are changing Query contexts.
589  * ----------------
590  */
591 typedef enum SubqueryScanStatus
592 {
597 
598 typedef struct SubqueryScan
599 {
604 
605 /* ----------------
606  * FunctionScan node
607  * ----------------
608  */
609 typedef struct FunctionScan
610 {
612  List *functions; /* list of RangeTblFunction nodes */
613  bool funcordinality; /* WITH ORDINALITY */
615 
616 /* ----------------
617  * ValuesScan node
618  * ----------------
619  */
620 typedef struct ValuesScan
621 {
623  List *values_lists; /* list of expression lists */
625 
626 /* ----------------
627  * TableFunc scan node
628  * ----------------
629  */
630 typedef struct TableFuncScan
631 {
633  TableFunc *tablefunc; /* table function node */
635 
636 /* ----------------
637  * CteScan node
638  * ----------------
639  */
640 typedef struct CteScan
641 {
643  int ctePlanId; /* ID of init SubPlan for CTE */
644  int cteParam; /* ID of Param representing CTE output */
646 
647 /* ----------------
648  * NamedTuplestoreScan node
649  * ----------------
650  */
651 typedef struct NamedTuplestoreScan
652 {
654  char *enrname; /* Name given to Ephemeral Named Relation */
656 
657 /* ----------------
658  * WorkTableScan node
659  * ----------------
660  */
661 typedef struct WorkTableScan
662 {
664  int wtParam; /* ID of Param representing work table */
666 
667 /* ----------------
668  * ForeignScan node
669  *
670  * fdw_exprs and fdw_private are both under the control of the foreign-data
671  * wrapper, but fdw_exprs is presumed to contain expression trees and will
672  * be post-processed accordingly by the planner; fdw_private won't be.
673  * Note that everything in both lists must be copiable by copyObject().
674  * One way to store an arbitrary blob of bytes is to represent it as a bytea
675  * Const. Usually, though, you'll be better off choosing a representation
676  * that can be dumped usefully by nodeToString().
677  *
678  * fdw_scan_tlist is a targetlist describing the contents of the scan tuple
679  * returned by the FDW; it can be NIL if the scan tuple matches the declared
680  * rowtype of the foreign table, which is the normal case for a simple foreign
681  * table scan. (If the plan node represents a foreign join, fdw_scan_tlist
682  * is required since there is no rowtype available from the system catalogs.)
683  * When fdw_scan_tlist is provided, Vars in the node's tlist and quals must
684  * have varno INDEX_VAR, and their varattnos correspond to resnos in the
685  * fdw_scan_tlist (which are also column numbers in the actual scan tuple).
686  * fdw_scan_tlist is never actually executed; it just holds expression trees
687  * describing what is in the scan tuple's columns.
688  *
689  * fdw_recheck_quals should contain any quals which the core system passed to
690  * the FDW but which were not added to scan.plan.qual; that is, it should
691  * contain the quals being checked remotely. This is needed for correct
692  * behavior during EvalPlanQual rechecks.
693  *
694  * When the plan node represents a foreign join, scan.scanrelid is zero and
695  * fs_relids must be consulted to identify the join relation. (fs_relids
696  * is valid for simple scans as well, but will always match scan.scanrelid.)
697  * fs_relids includes outer joins; fs_base_relids does not.
698  *
699  * If the FDW's PlanDirectModify() callback decides to repurpose a ForeignScan
700  * node to perform the UPDATE or DELETE operation directly in the remote
701  * server, it sets 'operation' and 'resultRelation' to identify the operation
702  * type and target relation. Note that these fields are only set if the
703  * modification is performed *fully* remotely; otherwise, the modification is
704  * driven by a local ModifyTable node and 'operation' is left to CMD_SELECT.
705  * ----------------
706  */
707 typedef struct ForeignScan
708 {
710  CmdType operation; /* SELECT/INSERT/UPDATE/DELETE */
711  Index resultRelation; /* direct modification target's RT index */
712  Oid checkAsUser; /* user to perform the scan as; 0 means to
713  * check as current user */
714  Oid fs_server; /* OID of foreign server */
715  List *fdw_exprs; /* expressions that FDW may evaluate */
716  List *fdw_private; /* private data for FDW */
717  List *fdw_scan_tlist; /* optional tlist describing scan tuple */
718  List *fdw_recheck_quals; /* original quals not in scan.plan.qual */
719  Bitmapset *fs_relids; /* base+OJ RTIs generated by this scan */
720  Bitmapset *fs_base_relids; /* base RTIs generated by this scan */
721  bool fsSystemCol; /* true if any "system column" is needed */
723 
724 /* ----------------
725  * CustomScan node
726  *
727  * The comments for ForeignScan's fdw_exprs, fdw_private, fdw_scan_tlist,
728  * and fs_relids fields apply equally to CustomScan's custom_exprs,
729  * custom_private, custom_scan_tlist, and custom_relids fields. The
730  * convention of setting scan.scanrelid to zero for joins applies as well.
731  *
732  * Note that since Plan trees can be copied, custom scan providers *must*
733  * fit all plan data they need into those fields; embedding CustomScan in
734  * a larger struct will not work.
735  * ----------------
736  */
737 struct CustomScanMethods;
738 
739 typedef struct CustomScan
740 {
742  uint32 flags; /* mask of CUSTOMPATH_* flags, see
743  * nodes/extensible.h */
744  List *custom_plans; /* list of Plan nodes, if any */
745  List *custom_exprs; /* expressions that custom code may evaluate */
746  List *custom_private; /* private data for custom code */
747  List *custom_scan_tlist; /* optional tlist describing scan tuple */
748  Bitmapset *custom_relids; /* RTIs generated by this scan */
749 
750  /*
751  * NOTE: The method field of CustomScan is required to be a pointer to a
752  * static table of callback functions. So we don't copy the table itself,
753  * just reference the original one.
754  */
755  const struct CustomScanMethods *methods;
757 
758 /*
759  * ==========
760  * Join nodes
761  * ==========
762  */
763 
764 /* ----------------
765  * Join node
766  *
767  * jointype: rule for joining tuples from left and right subtrees
768  * inner_unique each outer tuple can match to no more than one inner tuple
769  * joinqual: qual conditions that came from JOIN/ON or JOIN/USING
770  * (plan.qual contains conditions that came from WHERE)
771  *
772  * When jointype is INNER, joinqual and plan.qual are semantically
773  * interchangeable. For OUTER jointypes, the two are *not* interchangeable;
774  * only joinqual is used to determine whether a match has been found for
775  * the purpose of deciding whether to generate null-extended tuples.
776  * (But plan.qual is still applied before actually returning a tuple.)
777  * For an outer join, only joinquals are allowed to be used as the merge
778  * or hash condition of a merge or hash join.
779  *
780  * inner_unique is set if the joinquals are such that no more than one inner
781  * tuple could match any given outer tuple. This allows the executor to
782  * skip searching for additional matches. (This must be provable from just
783  * the joinquals, ignoring plan.qual, due to where the executor tests it.)
784  * ----------------
785  */
786 typedef struct Join
787 {
788  pg_node_attr(abstract)
789 
790  Plan plan;
791  JoinType jointype;
792  bool inner_unique;
793  List *joinqual; /* JOIN quals (in addition to plan.qual) */
795 
796 /* ----------------
797  * nest loop join node
798  *
799  * The nestParams list identifies any executor Params that must be passed
800  * into execution of the inner subplan carrying values from the current row
801  * of the outer subplan. Currently we restrict these values to be simple
802  * Vars, but perhaps someday that'd be worth relaxing. (Note: during plan
803  * creation, the paramval can actually be a PlaceHolderVar expression; but it
804  * must be a Var with varno OUTER_VAR by the time it gets to the executor.)
805  * ----------------
806  */
807 typedef struct NestLoop
808 {
810  List *nestParams; /* list of NestLoopParam nodes */
812 
813 typedef struct NestLoopParam
814 {
815  pg_node_attr(no_equal, no_query_jumble)
816 
817  NodeTag type;
818  int paramno; /* number of the PARAM_EXEC Param to set */
819  Var *paramval; /* outer-relation Var to assign to Param */
821 
822 /* ----------------
823  * merge join node
824  *
825  * The expected ordering of each mergeable column is described by a btree
826  * opfamily OID, a collation OID, a direction (BTLessStrategyNumber or
827  * BTGreaterStrategyNumber) and a nulls-first flag. Note that the two sides
828  * of each mergeclause may be of different datatypes, but they are ordered the
829  * same way according to the common opfamily and collation. The operator in
830  * each mergeclause must be an equality operator of the indicated opfamily.
831  * ----------------
832  */
833 typedef struct MergeJoin
834 {
836 
837  /* Can we skip mark/restore calls? */
839 
840  /* mergeclauses as expression trees */
842 
843  /* these are arrays, but have the same length as the mergeclauses list: */
844 
845  /* per-clause OIDs of btree opfamilies */
846  Oid *mergeFamilies pg_node_attr(array_size(mergeclauses));
847 
848  /* per-clause OIDs of collations */
849  Oid *mergeCollations pg_node_attr(array_size(mergeclauses));
850 
851  /* per-clause ordering (ASC or DESC) */
852  int *mergeStrategies pg_node_attr(array_size(mergeclauses));
853 
854  /* per-clause nulls ordering */
855  bool *mergeNullsFirst pg_node_attr(array_size(mergeclauses));
857 
858 /* ----------------
859  * hash join node
860  * ----------------
861  */
862 typedef struct HashJoin
863 {
868 
869  /*
870  * List of expressions to be hashed for tuples from the outer plan, to
871  * perform lookups in the hashtable over the inner plan.
872  */
875 
876 /* ----------------
877  * materialization node
878  * ----------------
879  */
880 typedef struct Material
881 {
884 
885 /* ----------------
886  * memoize node
887  * ----------------
888  */
889 typedef struct Memoize
890 {
892 
893  /* size of the two arrays below */
894  int numKeys;
895 
896  /* hash operators for each key */
897  Oid *hashOperators pg_node_attr(array_size(numKeys));
898 
899  /* collations for each key */
900  Oid *collations pg_node_attr(array_size(numKeys));
901 
902  /* cache keys in the form of exprs containing parameters */
904 
905  /*
906  * true if the cache entry should be marked as complete after we store the
907  * first tuple in it.
908  */
909  bool singlerow;
910 
911  /*
912  * true when cache key should be compared bit by bit, false when using
913  * hash equality ops
914  */
916 
917  /*
918  * The maximum number of entries that the planner expects will fit in the
919  * cache, or 0 if unknown
920  */
922 
923  /* paramids from param_exprs */
926 
927 /* ----------------
928  * sort node
929  * ----------------
930  */
931 typedef struct Sort
932 {
934 
935  /* number of sort-key columns */
936  int numCols;
937 
938  /* their indexes in the target list */
939  AttrNumber *sortColIdx pg_node_attr(array_size(numCols));
940 
941  /* OIDs of operators to sort them by */
942  Oid *sortOperators pg_node_attr(array_size(numCols));
943 
944  /* OIDs of collations */
945  Oid *collations pg_node_attr(array_size(numCols));
946 
947  /* NULLS FIRST/LAST directions */
948  bool *nullsFirst pg_node_attr(array_size(numCols));
950 
951 /* ----------------
952  * incremental sort node
953  * ----------------
954  */
955 typedef struct IncrementalSort
956 {
958  int nPresortedCols; /* number of presorted columns */
960 
961 /* ---------------
962  * group node -
963  * Used for queries with GROUP BY (but no aggregates) specified.
964  * The input must be presorted according to the grouping columns.
965  * ---------------
966  */
967 typedef struct Group
968 {
970 
971  /* number of grouping columns */
972  int numCols;
973 
974  /* their indexes in the target list */
975  AttrNumber *grpColIdx pg_node_attr(array_size(numCols));
976 
977  /* equality operators to compare with */
978  Oid *grpOperators pg_node_attr(array_size(numCols));
979  Oid *grpCollations pg_node_attr(array_size(numCols));
981 
982 /* ---------------
983  * aggregate node
984  *
985  * An Agg node implements plain or grouped aggregation. For grouped
986  * aggregation, we can work with presorted input or unsorted input;
987  * the latter strategy uses an internal hashtable.
988  *
989  * Notice the lack of any direct info about the aggregate functions to be
990  * computed. They are found by scanning the node's tlist and quals during
991  * executor startup. (It is possible that there are no aggregate functions;
992  * this could happen if they get optimized away by constant-folding, or if
993  * we are using the Agg node to implement hash-based grouping.)
994  * ---------------
995  */
996 typedef struct Agg
997 {
999 
1000  /* basic strategy, see nodes.h */
1002 
1003  /* agg-splitting mode, see nodes.h */
1005 
1006  /* number of grouping columns */
1007  int numCols;
1008 
1009  /* their indexes in the target list */
1010  AttrNumber *grpColIdx pg_node_attr(array_size(numCols));
1011 
1012  /* equality operators to compare with */
1013  Oid *grpOperators pg_node_attr(array_size(numCols));
1014  Oid *grpCollations pg_node_attr(array_size(numCols));
1015 
1016  /* estimated number of groups in input */
1018 
1019  /* for pass-by-ref transition data */
1021 
1022  /* IDs of Params used in Aggref inputs */
1024 
1025  /* Note: planner provides numGroups & aggParams only in HASHED/MIXED case */
1026 
1027  /* grouping sets to use */
1029 
1030  /* chained Agg/Sort nodes */
1033 
1034 /* ----------------
1035  * window aggregate node
1036  * ----------------
1037  */
1038 typedef struct WindowAgg
1039 {
1041 
1042  /* ID referenced by window functions */
1044 
1045  /* number of columns in partition clause */
1047 
1048  /* their indexes in the target list */
1049  AttrNumber *partColIdx pg_node_attr(array_size(partNumCols));
1050 
1051  /* equality operators for partition columns */
1052  Oid *partOperators pg_node_attr(array_size(partNumCols));
1053 
1054  /* collations for partition columns */
1055  Oid *partCollations pg_node_attr(array_size(partNumCols));
1056 
1057  /* number of columns in ordering clause */
1059 
1060  /* their indexes in the target list */
1061  AttrNumber *ordColIdx pg_node_attr(array_size(ordNumCols));
1062 
1063  /* equality operators for ordering columns */
1064  Oid *ordOperators pg_node_attr(array_size(ordNumCols));
1065 
1066  /* collations for ordering columns */
1067  Oid *ordCollations pg_node_attr(array_size(ordNumCols));
1068 
1069  /* frame_clause options, see WindowDef */
1071 
1072  /* expression for starting bound, if any */
1074 
1075  /* expression for ending bound, if any */
1077 
1078  /* qual to help short-circuit execution */
1080 
1081  /* runCondition for display in EXPLAIN */
1083 
1084  /* these fields are used with RANGE offset PRECEDING/FOLLOWING: */
1085 
1086  /* in_range function for startOffset */
1088 
1089  /* in_range function for endOffset */
1091 
1092  /* collation for in_range tests */
1094 
1095  /* use ASC sort order for in_range tests? */
1097 
1098  /* nulls sort first for in_range tests? */
1100 
1101  /*
1102  * false for all apart from the WindowAgg that's closest to the root of
1103  * the plan
1104  */
1107 
1108 /* ----------------
1109  * unique node
1110  * ----------------
1111  */
1112 typedef struct Unique
1113 {
1115 
1116  /* number of columns to check for uniqueness */
1117  int numCols;
1118 
1119  /* their indexes in the target list */
1120  AttrNumber *uniqColIdx pg_node_attr(array_size(numCols));
1121 
1122  /* equality operators to compare with */
1123  Oid *uniqOperators pg_node_attr(array_size(numCols));
1124 
1125  /* collations for equality comparisons */
1126  Oid *uniqCollations pg_node_attr(array_size(numCols));
1128 
1129 /* ------------
1130  * gather node
1131  *
1132  * Note: rescan_param is the ID of a PARAM_EXEC parameter slot. That slot
1133  * will never actually contain a value, but the Gather node must flag it as
1134  * having changed whenever it is rescanned. The child parallel-aware scan
1135  * nodes are marked as depending on that parameter, so that the rescan
1136  * machinery is aware that their output is likely to change across rescans.
1137  * In some cases we don't need a rescan Param, so rescan_param is set to -1.
1138  * ------------
1139  */
1140 typedef struct Gather
1141 {
1143  int num_workers; /* planned number of worker processes */
1144  int rescan_param; /* ID of Param that signals a rescan, or -1 */
1145  bool single_copy; /* don't execute plan more than once */
1146  bool invisible; /* suppress EXPLAIN display (for testing)? */
1147  Bitmapset *initParam; /* param id's of initplans which are referred
1148  * at gather or one of it's child node */
1150 
1151 /* ------------
1152  * gather merge node
1153  * ------------
1154  */
1155 typedef struct GatherMerge
1156 {
1158 
1159  /* planned number of worker processes */
1161 
1162  /* ID of Param that signals a rescan, or -1 */
1164 
1165  /* remaining fields are just like the sort-key info in struct Sort */
1166 
1167  /* number of sort-key columns */
1168  int numCols;
1169 
1170  /* their indexes in the target list */
1171  AttrNumber *sortColIdx pg_node_attr(array_size(numCols));
1172 
1173  /* OIDs of operators to sort them by */
1174  Oid *sortOperators pg_node_attr(array_size(numCols));
1175 
1176  /* OIDs of collations */
1177  Oid *collations pg_node_attr(array_size(numCols));
1178 
1179  /* NULLS FIRST/LAST directions */
1180  bool *nullsFirst pg_node_attr(array_size(numCols));
1181 
1182  /*
1183  * param id's of initplans which are referred at gather merge or one of
1184  * it's child node
1185  */
1188 
1189 /* ----------------
1190  * hash build node
1191  *
1192  * If the executor is supposed to try to apply skew join optimization, then
1193  * skewTable/skewColumn/skewInherit identify the outer relation's join key
1194  * column, from which the relevant MCV statistics can be fetched.
1195  * ----------------
1196  */
1197 typedef struct Hash
1198 {
1200 
1201  /*
1202  * List of expressions to be hashed for tuples from Hash's outer plan,
1203  * needed to put them into the hashtable.
1204  */
1205  List *hashkeys; /* hash keys for the hashjoin condition */
1206  Oid skewTable; /* outer join key's table OID, or InvalidOid */
1207  AttrNumber skewColumn; /* outer join key's column #, or zero */
1208  bool skewInherit; /* is outer join rel an inheritance tree? */
1209  /* all other info is in the parent HashJoin node */
1210  Cardinality rows_total; /* estimate total rows if parallel_aware */
1212 
1213 /* ----------------
1214  * setop node
1215  * ----------------
1216  */
1217 typedef struct SetOp
1218 {
1220 
1221  /* what to do, see nodes.h */
1223 
1224  /* how to do it, see nodes.h */
1226 
1227  /* number of columns to check for duplicate-ness */
1228  int numCols;
1229 
1230  /* their indexes in the target list */
1231  AttrNumber *dupColIdx pg_node_attr(array_size(numCols));
1232 
1233  /* equality operators to compare with */
1234  Oid *dupOperators pg_node_attr(array_size(numCols));
1235  Oid *dupCollations pg_node_attr(array_size(numCols));
1236 
1237  /* where is the flag column, if any */
1239 
1240  /* flag value for first input relation */
1242 
1243  /* estimated number of groups in input */
1246 
1247 /* ----------------
1248  * lock-rows node
1249  *
1250  * rowMarks identifies the rels to be locked by this node; it should be
1251  * a subset of the rowMarks listed in the top-level PlannedStmt.
1252  * epqParam is a Param that all scan nodes below this one must depend on.
1253  * It is used to force re-evaluation of the plan during EvalPlanQual.
1254  * ----------------
1255  */
1256 typedef struct LockRows
1257 {
1259  List *rowMarks; /* a list of PlanRowMark's */
1260  int epqParam; /* ID of Param for EvalPlanQual re-eval */
1262 
1263 /* ----------------
1264  * limit node
1265  *
1266  * Note: as of Postgres 8.2, the offset and count expressions are expected
1267  * to yield int8, rather than int4 as before.
1268  * ----------------
1269  */
1270 typedef struct Limit
1271 {
1273 
1274  /* OFFSET parameter, or NULL if none */
1276 
1277  /* COUNT parameter, or NULL if none */
1279 
1280  /* limit type */
1282 
1283  /* number of columns to check for similarity */
1285 
1286  /* their indexes in the target list */
1287  AttrNumber *uniqColIdx pg_node_attr(array_size(uniqNumCols));
1288 
1289  /* equality operators to compare with */
1290  Oid *uniqOperators pg_node_attr(array_size(uniqNumCols));
1291 
1292  /* collations for equality comparisons */
1293  Oid *uniqCollations pg_node_attr(array_size(uniqNumCols));
1295 
1296 
1297 /*
1298  * RowMarkType -
1299  * enums for types of row-marking operations
1300  *
1301  * The first four of these values represent different lock strengths that
1302  * we can take on tuples according to SELECT FOR [KEY] UPDATE/SHARE requests.
1303  * We support these on regular tables, as well as on foreign tables whose FDWs
1304  * report support for late locking. For other foreign tables, any locking
1305  * that might be done for such requests must happen during the initial row
1306  * fetch; their FDWs provide no mechanism for going back to lock a row later.
1307  * This means that the semantics will be a bit different than for a local
1308  * table; in particular we are likely to lock more rows than would be locked
1309  * locally, since remote rows will be locked even if they then fail
1310  * locally-checked restriction or join quals. However, the prospect of
1311  * doing a separate remote query to lock each selected row is usually pretty
1312  * unappealing, so early locking remains a credible design choice for FDWs.
1313  *
1314  * When doing UPDATE/DELETE/MERGE/SELECT FOR UPDATE/SHARE, we have to uniquely
1315  * identify all the source rows, not only those from the target relations, so
1316  * that we can perform EvalPlanQual rechecking at need. For plain tables we
1317  * can just fetch the TID, much as for a target relation; this case is
1318  * represented by ROW_MARK_REFERENCE. Otherwise (for example for VALUES or
1319  * FUNCTION scans) we have to copy the whole row value. ROW_MARK_COPY is
1320  * pretty inefficient, since most of the time we'll never need the data; but
1321  * fortunately the overhead is usually not performance-critical in practice.
1322  * By default we use ROW_MARK_COPY for foreign tables, but if the FDW has
1323  * a concept of rowid it can request to use ROW_MARK_REFERENCE instead.
1324  * (Again, this probably doesn't make sense if a physical remote fetch is
1325  * needed, but for FDWs that map to local storage it might be credible.)
1326  */
1327 typedef enum RowMarkType
1328 {
1329  ROW_MARK_EXCLUSIVE, /* obtain exclusive tuple lock */
1330  ROW_MARK_NOKEYEXCLUSIVE, /* obtain no-key exclusive tuple lock */
1331  ROW_MARK_SHARE, /* obtain shared tuple lock */
1332  ROW_MARK_KEYSHARE, /* obtain keyshare tuple lock */
1333  ROW_MARK_REFERENCE, /* just fetch the TID, don't lock it */
1334  ROW_MARK_COPY, /* physically copy the row value */
1336 
1337 #define RowMarkRequiresRowShareLock(marktype) ((marktype) <= ROW_MARK_KEYSHARE)
1338 
1339 /*
1340  * PlanRowMark -
1341  * plan-time representation of FOR [KEY] UPDATE/SHARE clauses
1342  *
1343  * When doing UPDATE/DELETE/MERGE/SELECT FOR UPDATE/SHARE, we create a separate
1344  * PlanRowMark node for each non-target relation in the query. Relations that
1345  * are not specified as FOR UPDATE/SHARE are marked ROW_MARK_REFERENCE (if
1346  * regular tables or supported foreign tables) or ROW_MARK_COPY (if not).
1347  *
1348  * Initially all PlanRowMarks have rti == prti and isParent == false.
1349  * When the planner discovers that a relation is the root of an inheritance
1350  * tree, it sets isParent true, and adds an additional PlanRowMark to the
1351  * list for each child relation (including the target rel itself in its role
1352  * as a child, if it is not a partitioned table). Any non-leaf partitioned
1353  * child relations will also have entries with isParent = true. The child
1354  * entries have rti == child rel's RT index and prti == top parent's RT index,
1355  * and can therefore be recognized as children by the fact that prti != rti.
1356  * The parent's allMarkTypes field gets the OR of (1<<markType) across all
1357  * its children (this definition allows children to use different markTypes).
1358  *
1359  * The planner also adds resjunk output columns to the plan that carry
1360  * information sufficient to identify the locked or fetched rows. When
1361  * markType != ROW_MARK_COPY, these columns are named
1362  * tableoid%u OID of table
1363  * ctid%u TID of row
1364  * The tableoid column is only present for an inheritance hierarchy.
1365  * When markType == ROW_MARK_COPY, there is instead a single column named
1366  * wholerow%u whole-row value of relation
1367  * (An inheritance hierarchy could have all three resjunk output columns,
1368  * if some children use a different markType than others.)
1369  * In all three cases, %u represents the rowmark ID number (rowmarkId).
1370  * This number is unique within a plan tree, except that child relation
1371  * entries copy their parent's rowmarkId. (Assigning unique numbers
1372  * means we needn't renumber rowmarkIds when flattening subqueries, which
1373  * would require finding and renaming the resjunk columns as well.)
1374  * Note this means that all tables in an inheritance hierarchy share the
1375  * same resjunk column names.
1376  */
1377 typedef struct PlanRowMark
1378 {
1379  pg_node_attr(no_equal, no_query_jumble)
1380 
1381  NodeTag type;
1382  Index rti; /* range table index of markable relation */
1383  Index prti; /* range table index of parent relation */
1384  Index rowmarkId; /* unique identifier for resjunk columns */
1385  RowMarkType markType; /* see enum above */
1386  int allMarkTypes; /* OR of (1<<markType) for all children */
1387  LockClauseStrength strength; /* LockingClause's strength, or LCS_NONE */
1388  LockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED options */
1389  bool isParent; /* true if this is a "dummy" parent entry */
1391 
1392 
1393 /*
1394  * Node types to represent partition pruning information.
1395  */
1396 
1397 /*
1398  * PartitionPruneInfo - Details required to allow the executor to prune
1399  * partitions.
1400  *
1401  * Here we store mapping details to allow translation of a partitioned table's
1402  * index as returned by the partition pruning code into subplan indexes for
1403  * plan types which support arbitrary numbers of subplans, such as Append.
1404  * We also store various details to tell the executor when it should be
1405  * performing partition pruning.
1406  *
1407  * Each PartitionedRelPruneInfo describes the partitioning rules for a single
1408  * partitioned table (a/k/a level of partitioning). Since a partitioning
1409  * hierarchy could contain multiple levels, we represent it by a List of
1410  * PartitionedRelPruneInfos, where the first entry represents the topmost
1411  * partitioned table and additional entries represent non-leaf child
1412  * partitions, ordered such that parents appear before their children.
1413  * Then, since an Append-type node could have multiple partitioning
1414  * hierarchies among its children, we have an unordered List of those Lists.
1415  *
1416  * prune_infos List of Lists containing PartitionedRelPruneInfo nodes,
1417  * one sublist per run-time-prunable partition hierarchy
1418  * appearing in the parent plan node's subplans.
1419  * other_subplans Indexes of any subplans that are not accounted for
1420  * by any of the PartitionedRelPruneInfo nodes in
1421  * "prune_infos". These subplans must not be pruned.
1422  */
1423 typedef struct PartitionPruneInfo
1424 {
1425  pg_node_attr(no_equal, no_query_jumble)
1426 
1427  NodeTag type;
1431 
1432 /*
1433  * PartitionedRelPruneInfo - Details required to allow the executor to prune
1434  * partitions for a single partitioned table.
1435  *
1436  * subplan_map[] and subpart_map[] are indexed by partition index of the
1437  * partitioned table referenced by 'rtindex', the partition index being the
1438  * order that the partitions are defined in the table's PartitionDesc. For a
1439  * leaf partition p, subplan_map[p] contains the zero-based index of the
1440  * partition's subplan in the parent plan's subplan list; it is -1 if the
1441  * partition is non-leaf or has been pruned. For a non-leaf partition p,
1442  * subpart_map[p] contains the zero-based index of that sub-partition's
1443  * PartitionedRelPruneInfo in the hierarchy's PartitionedRelPruneInfo list;
1444  * it is -1 if the partition is a leaf or has been pruned. Note that subplan
1445  * indexes, as stored in 'subplan_map', are global across the parent plan
1446  * node, but partition indexes are valid only within a particular hierarchy.
1447  * relid_map[p] contains the partition's OID, or 0 if the partition was pruned.
1448  */
1450 {
1451  pg_node_attr(no_equal, no_query_jumble)
1452 
1453  NodeTag type;
1454 
1455  /* RT index of partition rel for this level */
1457 
1458  /* Indexes of all partitions which subplans or subparts are present for */
1460 
1461  /* Length of the following arrays: */
1462  int nparts;
1463 
1464  /* subplan index by partition index, or -1 */
1465  int *subplan_map pg_node_attr(array_size(nparts));
1466 
1467  /* subpart index by partition index, or -1 */
1468  int *subpart_map pg_node_attr(array_size(nparts));
1469 
1470  /* relation OID by partition index, or 0 */
1471  Oid *relid_map pg_node_attr(array_size(nparts));
1472 
1473  /*
1474  * initial_pruning_steps shows how to prune during executor startup (i.e.,
1475  * without use of any PARAM_EXEC Params); it is NIL if no startup pruning
1476  * is required. exec_pruning_steps shows how to prune with PARAM_EXEC
1477  * Params; it is NIL if no per-scan pruning is required.
1478  */
1479  List *initial_pruning_steps; /* List of PartitionPruneStep */
1480  List *exec_pruning_steps; /* List of PartitionPruneStep */
1481 
1482  /* All PARAM_EXEC Param IDs in exec_pruning_steps */
1485 
1486 /*
1487  * Abstract Node type for partition pruning steps (there are no concrete
1488  * Nodes of this type).
1489  *
1490  * step_id is the global identifier of the step within its pruning context.
1491  */
1492 typedef struct PartitionPruneStep
1493 {
1494  pg_node_attr(abstract, no_equal, no_query_jumble)
1495 
1496  NodeTag type;
1497  int step_id;
1499 
1500 /*
1501  * PartitionPruneStepOp - Information to prune using a set of mutually ANDed
1502  * OpExpr clauses
1503  *
1504  * This contains information extracted from up to partnatts OpExpr clauses,
1505  * where partnatts is the number of partition key columns. 'opstrategy' is the
1506  * strategy of the operator in the clause matched to the last partition key.
1507  * 'exprs' contains expressions which comprise the lookup key to be passed to
1508  * the partition bound search function. 'cmpfns' contains the OIDs of
1509  * comparison functions used to compare aforementioned expressions with
1510  * partition bounds. Both 'exprs' and 'cmpfns' contain the same number of
1511  * items, up to partnatts items.
1512  *
1513  * Once we find the offset of a partition bound using the lookup key, we
1514  * determine which partitions to include in the result based on the value of
1515  * 'opstrategy'. For example, if it were equality, we'd return just the
1516  * partition that would contain that key or a set of partitions if the key
1517  * didn't consist of all partitioning columns. For non-equality strategies,
1518  * we'd need to include other partitions as appropriate.
1519  *
1520  * 'nullkeys' is the set containing the offset of the partition keys (0 to
1521  * partnatts - 1) that were matched to an IS NULL clause. This is only
1522  * considered for hash partitioning as we need to pass which keys are null
1523  * to the hash partition bound search function. It is never possible to
1524  * have an expression be present in 'exprs' for a given partition key and
1525  * the corresponding bit set in 'nullkeys'.
1526  */
1527 typedef struct PartitionPruneStepOp
1528 {
1530 
1536 
1537 /*
1538  * PartitionPruneStepCombine - Information to prune using a BoolExpr clause
1539  *
1540  * For BoolExpr clauses, we combine the set of partitions determined for each
1541  * of the argument clauses.
1542  */
1544 {
1548 
1550 {
1552 
1556 
1557 
1558 /*
1559  * Plan invalidation info
1560  *
1561  * We track the objects on which a PlannedStmt depends in two ways:
1562  * relations are recorded as a simple list of OIDs, and everything else
1563  * is represented as a list of PlanInvalItems. A PlanInvalItem is designed
1564  * to be used with the syscache invalidation mechanism, so it identifies a
1565  * system catalog entry by cache ID and hash value.
1566  */
1567 typedef struct PlanInvalItem
1568 {
1569  pg_node_attr(no_equal, no_query_jumble)
1570 
1571  NodeTag type;
1572  int cacheId; /* a syscache ID, see utils/syscache.h */
1573  uint32 hashValue; /* hash value of object's cache lookup key */
1575 
1576 /*
1577  * MonotonicFunction
1578  *
1579  * Allows the planner to track monotonic properties of functions. A function
1580  * is monotonically increasing if a subsequent call cannot yield a lower value
1581  * than the previous call. A monotonically decreasing function cannot yield a
1582  * higher value on subsequent calls, and a function which is both must return
1583  * the same value on each call.
1584  */
1585 typedef enum MonotonicFunction
1586 {
1592 
1593 #endif /* PLANNODES_H */
int16 AttrNumber
Definition: attnum.h:21
unsigned int uint32
Definition: c.h:506
unsigned int Index
Definition: c.h:614
LockWaitPolicy
Definition: lockoptions.h:37
LockClauseStrength
Definition: lockoptions.h:22
SetOpCmd
Definition: nodes.h:396
SetOpStrategy
Definition: nodes.h:404
double Cost
Definition: nodes.h:251
OnConflictAction
Definition: nodes.h:416
double Cardinality
Definition: nodes.h:252
CmdType
Definition: nodes.h:263
AggStrategy
Definition: nodes.h:352
NodeTag
Definition: nodes.h:27
AggSplit
Definition: nodes.h:374
LimitOption
Definition: nodes.h:429
int ParseLoc
Definition: nodes.h:240
JoinType
Definition: nodes.h:288
#define plan(x)
Definition: pg_regress.c:162
struct ForeignScan ForeignScan
struct TableFuncScan TableFuncScan
struct IndexScan IndexScan
struct MergeJoin MergeJoin
struct Memoize Memoize
struct Plan Plan
struct SampleScan SampleScan
struct WindowAgg WindowAgg
struct WorkTableScan WorkTableScan
struct ProjectSet ProjectSet
struct Sort Sort
struct PartitionedRelPruneInfo PartitionedRelPruneInfo
struct BitmapIndexScan BitmapIndexScan
struct TidScan TidScan
struct LockRows LockRows
struct TidRangeScan TidRangeScan
struct PartitionPruneStepOp PartitionPruneStepOp
SubqueryScanStatus
Definition: plannodes.h:592
@ SUBQUERY_SCAN_NONTRIVIAL
Definition: plannodes.h:595
@ SUBQUERY_SCAN_UNKNOWN
Definition: plannodes.h:593
@ SUBQUERY_SCAN_TRIVIAL
Definition: plannodes.h:594
struct PlanInvalItem PlanInvalItem
struct SubqueryScan SubqueryScan
PartitionPruneCombineOp
Definition: plannodes.h:1544
@ PARTPRUNE_COMBINE_INTERSECT
Definition: plannodes.h:1546
@ PARTPRUNE_COMBINE_UNION
Definition: plannodes.h:1545
struct IncrementalSort IncrementalSort
struct CteScan CteScan
struct NestLoop NestLoop
struct PlanRowMark PlanRowMark
struct Limit Limit
struct Unique Unique
struct BitmapOr BitmapOr
struct SeqScan SeqScan
struct HashJoin HashJoin
struct Group Group
struct PartitionPruneInfo PartitionPruneInfo
struct Append Append
struct Material Material
struct BitmapHeapScan BitmapHeapScan
struct NamedTuplestoreScan NamedTuplestoreScan
struct SetOp SetOp
struct NestLoopParam NestLoopParam
struct BitmapAnd BitmapAnd
struct GatherMerge GatherMerge
struct ModifyTable ModifyTable
struct PartitionPruneStep PartitionPruneStep
struct Hash Hash
RowMarkType
Definition: plannodes.h:1328
@ ROW_MARK_COPY
Definition: plannodes.h:1334
@ ROW_MARK_REFERENCE
Definition: plannodes.h:1333
@ ROW_MARK_SHARE
Definition: plannodes.h:1331
@ ROW_MARK_EXCLUSIVE
Definition: plannodes.h:1329
@ ROW_MARK_NOKEYEXCLUSIVE
Definition: plannodes.h:1330
@ ROW_MARK_KEYSHARE
Definition: plannodes.h:1332
MonotonicFunction
Definition: plannodes.h:1586
@ MONOTONICFUNC_NONE
Definition: plannodes.h:1587
@ MONOTONICFUNC_DECREASING
Definition: plannodes.h:1589
@ MONOTONICFUNC_INCREASING
Definition: plannodes.h:1588
@ MONOTONICFUNC_BOTH
Definition: plannodes.h:1590
struct RecursiveUnion RecursiveUnion
struct IndexOnlyScan IndexOnlyScan
struct FunctionScan FunctionScan
struct Result Result
struct MergeAppend MergeAppend
struct PartitionPruneStepCombine PartitionPruneStepCombine
struct CustomScan CustomScan
struct Agg Agg
struct ValuesScan ValuesScan
struct Gather Gather
struct PlannedStmt PlannedStmt
unsigned int Oid
Definition: postgres_ext.h:31
ScanDirection
Definition: sdir.h:25
uint16 StrategyNumber
Definition: stratnum.h:22
Definition: plannodes.h:997
AggSplit aggsplit
Definition: plannodes.h:1004
List * chain
Definition: plannodes.h:1031
long numGroups
Definition: plannodes.h:1017
AttrNumber *grpColIdx pg_node_attr(array_size(numCols))
List * groupingSets
Definition: plannodes.h:1028
Bitmapset * aggParams
Definition: plannodes.h:1023
Plan plan
Definition: plannodes.h:998
int numCols
Definition: plannodes.h:1007
uint64 transitionSpace
Definition: plannodes.h:1020
AggStrategy aggstrategy
Definition: plannodes.h:1001
Oid *grpCollations pg_node_attr(array_size(numCols))
Oid *grpOperators pg_node_attr(array_size(numCols))
int first_partial_plan
Definition: plannodes.h:276
struct PartitionPruneInfo * part_prune_info
Definition: plannodes.h:279
int nasyncplans
Definition: plannodes.h:270
Bitmapset * apprelids
Definition: plannodes.h:268
Plan plan
Definition: plannodes.h:267
List * appendplans
Definition: plannodes.h:269
Plan plan
Definition: plannodes.h:358
List * bitmapplans
Definition: plannodes.h:359
List * bitmapqualorig
Definition: plannodes.h:541
List * indexqualorig
Definition: plannodes.h:526
List * indexqual
Definition: plannodes.h:525
List * bitmapplans
Definition: plannodes.h:374
bool isshared
Definition: plannodes.h:373
Plan plan
Definition: plannodes.h:372
int ctePlanId
Definition: plannodes.h:643
int cteParam
Definition: plannodes.h:644
Scan scan
Definition: plannodes.h:642
uint32 flags
Definition: plannodes.h:742
List * custom_scan_tlist
Definition: plannodes.h:747
Scan scan
Definition: plannodes.h:741
List * custom_private
Definition: plannodes.h:746
Bitmapset * custom_relids
Definition: plannodes.h:748
List * custom_exprs
Definition: plannodes.h:745
const struct CustomScanMethods * methods
Definition: plannodes.h:755
List * custom_plans
Definition: plannodes.h:744
Oid checkAsUser
Definition: plannodes.h:712
CmdType operation
Definition: plannodes.h:710
Oid fs_server
Definition: plannodes.h:714
List * fdw_exprs
Definition: plannodes.h:715
bool fsSystemCol
Definition: plannodes.h:721
Bitmapset * fs_relids
Definition: plannodes.h:719
List * fdw_private
Definition: plannodes.h:716
Bitmapset * fs_base_relids
Definition: plannodes.h:720
Index resultRelation
Definition: plannodes.h:711
List * fdw_recheck_quals
Definition: plannodes.h:718
List * fdw_scan_tlist
Definition: plannodes.h:717
List * functions
Definition: plannodes.h:612
bool funcordinality
Definition: plannodes.h:613
Oid *sortOperators pg_node_attr(array_size(numCols))
Oid *collations pg_node_attr(array_size(numCols))
bool *nullsFirst pg_node_attr(array_size(numCols))
AttrNumber *sortColIdx pg_node_attr(array_size(numCols))
int rescan_param
Definition: plannodes.h:1163
Bitmapset * initParam
Definition: plannodes.h:1186
int num_workers
Definition: plannodes.h:1160
int num_workers
Definition: plannodes.h:1143
bool invisible
Definition: plannodes.h:1146
Bitmapset * initParam
Definition: plannodes.h:1147
bool single_copy
Definition: plannodes.h:1145
Plan plan
Definition: plannodes.h:1142
int rescan_param
Definition: plannodes.h:1144
int numCols
Definition: plannodes.h:972
Plan plan
Definition: plannodes.h:969
Oid *grpCollations pg_node_attr(array_size(numCols))
AttrNumber *grpColIdx pg_node_attr(array_size(numCols))
Oid *grpOperators pg_node_attr(array_size(numCols))
List * hashcollations
Definition: plannodes.h:867
List * hashclauses
Definition: plannodes.h:865
List * hashoperators
Definition: plannodes.h:866
Join join
Definition: plannodes.h:864
List * hashkeys
Definition: plannodes.h:873
AttrNumber skewColumn
Definition: plannodes.h:1207
List * hashkeys
Definition: plannodes.h:1205
Oid skewTable
Definition: plannodes.h:1206
bool skewInherit
Definition: plannodes.h:1208
Cardinality rows_total
Definition: plannodes.h:1210
Plan plan
Definition: plannodes.h:1199
List * indexqual
Definition: plannodes.h:496
List * recheckqual
Definition: plannodes.h:497
List * indextlist
Definition: plannodes.h:499
ScanDirection indexorderdir
Definition: plannodes.h:500
List * indexorderby
Definition: plannodes.h:498
List * indexorderby
Definition: plannodes.h:455
List * indexorderbyops
Definition: plannodes.h:457
ScanDirection indexorderdir
Definition: plannodes.h:458
Scan scan
Definition: plannodes.h:451
List * indexqualorig
Definition: plannodes.h:454
Oid indexid
Definition: plannodes.h:452
List * indexqual
Definition: plannodes.h:453
List * indexorderbyorig
Definition: plannodes.h:456
pg_node_attr(abstract) Plan plan
LimitOption limitOption
Definition: plannodes.h:1281
Plan plan
Definition: plannodes.h:1272
AttrNumber *uniqColIdx pg_node_attr(array_size(uniqNumCols))
Node * limitCount
Definition: plannodes.h:1278
Oid *uniqCollations pg_node_attr(array_size(uniqNumCols))
int uniqNumCols
Definition: plannodes.h:1284
Oid *uniqOperators pg_node_attr(array_size(uniqNumCols))
Node * limitOffset
Definition: plannodes.h:1275
Definition: pg_list.h:54
int epqParam
Definition: plannodes.h:1260
List * rowMarks
Definition: plannodes.h:1259
Plan plan
Definition: plannodes.h:1258
Plan plan
Definition: plannodes.h:882
Plan plan
Definition: plannodes.h:891
bool singlerow
Definition: plannodes.h:909
Bitmapset * keyparamids
Definition: plannodes.h:924
bool binary_mode
Definition: plannodes.h:915
int numKeys
Definition: plannodes.h:894
List * param_exprs
Definition: plannodes.h:903
uint32 est_entries
Definition: plannodes.h:921
Oid *hashOperators pg_node_attr(array_size(numKeys))
Oid *collations pg_node_attr(array_size(numKeys))
struct PartitionPruneInfo * part_prune_info
Definition: plannodes.h:314
Oid *sortOperators pg_node_attr(array_size(numCols))
Oid *collations pg_node_attr(array_size(numCols))
Bitmapset * apprelids
Definition: plannodes.h:292
bool *nullsFirst pg_node_attr(array_size(numCols))
List * mergeplans
Definition: plannodes.h:294
AttrNumber *sortColIdx pg_node_attr(array_size(numCols))
Oid *mergeFamilies pg_node_attr(array_size(mergeclauses))
List * mergeclauses
Definition: plannodes.h:841
Join join
Definition: plannodes.h:835
int *mergeStrategies pg_node_attr(array_size(mergeclauses))
Oid *mergeCollations pg_node_attr(array_size(mergeclauses))
bool skip_mark_restore
Definition: plannodes.h:838
bool *mergeNullsFirst pg_node_attr(array_size(mergeclauses))
List * updateColnosLists
Definition: plannodes.h:238
Index nominalRelation
Definition: plannodes.h:234
List * arbiterIndexes
Definition: plannodes.h:246
List * onConflictCols
Definition: plannodes.h:248
List * mergeJoinConditions
Definition: plannodes.h:254
CmdType operation
Definition: plannodes.h:232
int epqParam
Definition: plannodes.h:244
List * resultRelations
Definition: plannodes.h:237
Bitmapset * fdwDirectModifyPlans
Definition: plannodes.h:242
List * onConflictSet
Definition: plannodes.h:247
List * exclRelTlist
Definition: plannodes.h:251
List * mergeActionLists
Definition: plannodes.h:252
bool canSetTag
Definition: plannodes.h:233
List * fdwPrivLists
Definition: plannodes.h:241
bool partColsUpdated
Definition: plannodes.h:236
List * returningLists
Definition: plannodes.h:240
List * withCheckOptionLists
Definition: plannodes.h:239
Index rootRelation
Definition: plannodes.h:235
Node * onConflictWhere
Definition: plannodes.h:249
List * rowMarks
Definition: plannodes.h:243
OnConflictAction onConflictAction
Definition: plannodes.h:245
Index exclRelRTI
Definition: plannodes.h:250
Var * paramval
Definition: plannodes.h:819
pg_node_attr(no_equal, no_query_jumble) NodeTag type
List * nestParams
Definition: plannodes.h:810
Join join
Definition: plannodes.h:809
Definition: nodes.h:129
Bitmapset * other_subplans
Definition: plannodes.h:1429
pg_node_attr(no_equal, no_query_jumble) NodeTag type
PartitionPruneCombineOp combineOp
Definition: plannodes.h:1553
PartitionPruneStep step
Definition: plannodes.h:1551
PartitionPruneStep step
Definition: plannodes.h:1529
StrategyNumber opstrategy
Definition: plannodes.h:1531
Bitmapset * nullkeys
Definition: plannodes.h:1534
pg_node_attr(abstract, no_equal, no_query_jumble) NodeTag type
pg_node_attr(no_equal, no_query_jumble) NodeTag type
int *subpart_map pg_node_attr(array_size(nparts))
int *subplan_map pg_node_attr(array_size(nparts))
Bitmapset * present_parts
Definition: plannodes.h:1459
Bitmapset * execparamids
Definition: plannodes.h:1483
Oid *relid_map pg_node_attr(array_size(nparts))
uint32 hashValue
Definition: plannodes.h:1573
pg_node_attr(no_equal, no_query_jumble) NodeTag type
LockClauseStrength strength
Definition: plannodes.h:1387
Index prti
Definition: plannodes.h:1383
RowMarkType markType
Definition: plannodes.h:1385
LockWaitPolicy waitPolicy
Definition: plannodes.h:1388
bool isParent
Definition: plannodes.h:1389
Index rowmarkId
Definition: plannodes.h:1384
int allMarkTypes
Definition: plannodes.h:1386
pg_node_attr(no_equal, no_query_jumble) NodeTag type
Bitmapset * extParam
Definition: plannodes.h:170
struct Plan * lefttree
Definition: plannodes.h:154
bool async_capable
Definition: plannodes.h:146
Cost total_cost
Definition: plannodes.h:129
struct Plan * righttree
Definition: plannodes.h:155
bool parallel_aware
Definition: plannodes.h:140
Cost startup_cost
Definition: plannodes.h:128
List * qual
Definition: plannodes.h:153
int plan_width
Definition: plannodes.h:135
Bitmapset * allParam
Definition: plannodes.h:171
bool parallel_safe
Definition: plannodes.h:141
Cardinality plan_rows
Definition: plannodes.h:134
int plan_node_id
Definition: plannodes.h:151
List * targetlist
Definition: plannodes.h:152
pg_node_attr(abstract, no_equal, no_query_jumble) NodeTag type
List * initPlan
Definition: plannodes.h:156
struct Plan * planTree
Definition: plannodes.h:70
bool hasModifyingCTE
Definition: plannodes.h:58
List * appendRelations
Definition: plannodes.h:80
List * permInfos
Definition: plannodes.h:74
bool canSetTag
Definition: plannodes.h:60
List * rowMarks
Definition: plannodes.h:87
int jitFlags
Definition: plannodes.h:68
Bitmapset * rewindPlanIDs
Definition: plannodes.h:85
ParseLoc stmt_len
Definition: plannodes.h:99
bool hasReturning
Definition: plannodes.h:56
ParseLoc stmt_location
Definition: plannodes.h:98
List * invalItems
Definition: plannodes.h:91
bool transientPlan
Definition: plannodes.h:62
List * resultRelations
Definition: plannodes.h:78
List * subplans
Definition: plannodes.h:82
List * relationOids
Definition: plannodes.h:89
bool dependsOnRole
Definition: plannodes.h:64
CmdType commandType
Definition: plannodes.h:52
pg_node_attr(no_equal, no_query_jumble) NodeTag type
Node * utilityStmt
Definition: plannodes.h:95
List * rtable
Definition: plannodes.h:72
List * paramExecTypes
Definition: plannodes.h:93
bool parallelModeNeeded
Definition: plannodes.h:66
uint64 queryId
Definition: plannodes.h:54
Plan plan
Definition: plannodes.h:210
Oid *dupCollations pg_node_attr(array_size(numCols))
AttrNumber *dupColIdx pg_node_attr(array_size(numCols))
Oid *dupOperators pg_node_attr(array_size(numCols))
Node * resconstantqual
Definition: plannodes.h:199
Plan plan
Definition: plannodes.h:198
struct TableSampleClause * tablesample
Definition: plannodes.h:409
Scan scan
Definition: plannodes.h:407
Index scanrelid
Definition: plannodes.h:389
pg_node_attr(abstract) Plan plan
Scan scan
Definition: plannodes.h:398
Oid *dupOperators pg_node_attr(array_size(numCols))
SetOpStrategy strategy
Definition: plannodes.h:1225
AttrNumber flagColIdx
Definition: plannodes.h:1238
Oid *dupCollations pg_node_attr(array_size(numCols))
AttrNumber *dupColIdx pg_node_attr(array_size(numCols))
SetOpCmd cmd
Definition: plannodes.h:1222
int numCols
Definition: plannodes.h:1228
int firstFlag
Definition: plannodes.h:1241
Plan plan
Definition: plannodes.h:1219
long numGroups
Definition: plannodes.h:1244
int numCols
Definition: plannodes.h:936
Oid *collations pg_node_attr(array_size(numCols))
bool *nullsFirst pg_node_attr(array_size(numCols))
Plan plan
Definition: plannodes.h:933
Oid *sortOperators pg_node_attr(array_size(numCols))
AttrNumber *sortColIdx pg_node_attr(array_size(numCols))
SubqueryScanStatus scanstatus
Definition: plannodes.h:602
Plan * subplan
Definition: plannodes.h:601
TableFunc * tablefunc
Definition: plannodes.h:633
List * tidrangequals
Definition: plannodes.h:568
Scan scan
Definition: plannodes.h:554
List * tidquals
Definition: plannodes.h:555
Oid *uniqCollations pg_node_attr(array_size(numCols))
Oid *uniqOperators pg_node_attr(array_size(numCols))
AttrNumber *uniqColIdx pg_node_attr(array_size(numCols))
Plan plan
Definition: plannodes.h:1114
int numCols
Definition: plannodes.h:1117
Scan scan
Definition: plannodes.h:622
List * values_lists
Definition: plannodes.h:623
Definition: primnodes.h:248
Oid *partOperators pg_node_attr(array_size(partNumCols))
AttrNumber *partColIdx pg_node_attr(array_size(partNumCols))
int partNumCols
Definition: plannodes.h:1046
Oid endInRangeFunc
Definition: plannodes.h:1090
Node * endOffset
Definition: plannodes.h:1076
bool topWindow
Definition: plannodes.h:1105
Plan plan
Definition: plannodes.h:1040
List * runConditionOrig
Definition: plannodes.h:1082
Oid inRangeColl
Definition: plannodes.h:1093
Node * startOffset
Definition: plannodes.h:1073
List * runCondition
Definition: plannodes.h:1079
AttrNumber *ordColIdx pg_node_attr(array_size(ordNumCols))
Oid startInRangeFunc
Definition: plannodes.h:1087
bool inRangeAsc
Definition: plannodes.h:1096
Oid *partCollations pg_node_attr(array_size(partNumCols))
Index winref
Definition: plannodes.h:1043
Oid *ordOperators pg_node_attr(array_size(ordNumCols))
bool inRangeNullsFirst
Definition: plannodes.h:1099
Oid *ordCollations pg_node_attr(array_size(ordNumCols))
int ordNumCols
Definition: plannodes.h:1058
int frameOptions
Definition: plannodes.h:1070
const char * type