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