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