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