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