PostgreSQL Source Code  git master
pathnodes.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * pathnodes.h
4  * Definitions for planner's internal data structures, especially Paths.
5  *
6  * We don't support copying RelOptInfo, IndexOptInfo, or Path nodes.
7  * There are some subsidiary structs that are useful to copy, though.
8  *
9  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
10  * Portions Copyright (c) 1994, Regents of the University of California
11  *
12  * src/include/nodes/pathnodes.h
13  *
14  *-------------------------------------------------------------------------
15  */
16 #ifndef PATHNODES_H
17 #define PATHNODES_H
18 
19 #include "access/sdir.h"
20 #include "lib/stringinfo.h"
21 #include "nodes/params.h"
22 #include "nodes/parsenodes.h"
23 #include "storage/block.h"
24 
25 
26 /*
27  * Relids
28  * Set of relation identifiers (indexes into the rangetable).
29  */
30 typedef Bitmapset *Relids;
31 
32 /*
33  * When looking for a "cheapest path", this enum specifies whether we want
34  * cheapest startup cost or cheapest total cost.
35  */
36 typedef enum CostSelector
37 {
40 
41 /*
42  * The cost estimate produced by cost_qual_eval() includes both a one-time
43  * (startup) cost, and a per-tuple cost.
44  */
45 typedef struct QualCost
46 {
47  Cost startup; /* one-time cost */
48  Cost per_tuple; /* per-evaluation cost */
50 
51 /*
52  * Costing aggregate function execution requires these statistics about
53  * the aggregates to be executed by a given Agg node. Note that the costs
54  * include the execution costs of the aggregates' argument expressions as
55  * well as the aggregate functions themselves. Also, the fields must be
56  * defined so that initializing the struct to zeroes with memset is correct.
57  */
58 typedef struct AggClauseCosts
59 {
60  QualCost transCost; /* total per-input-row execution costs */
61  QualCost finalCost; /* total per-aggregated-row costs */
62  Size transitionSpace; /* space for pass-by-ref transition data */
64 
65 /*
66  * This enum identifies the different types of "upper" (post-scan/join)
67  * relations that we might deal with during planning.
68  */
69 typedef enum UpperRelationKind
70 {
71  UPPERREL_SETOP, /* result of UNION/INTERSECT/EXCEPT, if any */
72  UPPERREL_PARTIAL_GROUP_AGG, /* result of partial grouping/aggregation, if
73  * any */
74  UPPERREL_GROUP_AGG, /* result of grouping/aggregation, if any */
75  UPPERREL_WINDOW, /* result of window functions, if any */
76  UPPERREL_PARTIAL_DISTINCT, /* result of partial "SELECT DISTINCT", if any */
77  UPPERREL_DISTINCT, /* result of "SELECT DISTINCT", if any */
78  UPPERREL_ORDERED, /* result of ORDER BY, if any */
79  UPPERREL_FINAL /* result of any remaining top-level actions */
80  /* NB: UPPERREL_FINAL must be last enum entry; it's used to size arrays */
82 
83 /*----------
84  * PlannerGlobal
85  * Global information for planning/optimization
86  *
87  * PlannerGlobal holds state for an entire planner invocation; this state
88  * is shared across all levels of sub-Queries that exist in the command being
89  * planned.
90  *
91  * Not all fields are printed. (In some cases, there is no print support for
92  * the field type; in others, doing so would lead to infinite recursion.)
93  *----------
94  */
95 typedef struct PlannerGlobal
96 {
97  pg_node_attr(no_copy_equal, no_read)
98 
99  NodeTag type;
100 
101  /* Param values provided to planner() */
102  ParamListInfo boundParams pg_node_attr(read_write_ignore);
103 
104  /* Plans for SubPlan nodes */
106 
107  /* PlannerInfos for SubPlan nodes */
108  List *subroots pg_node_attr(read_write_ignore);
109 
110  /* indices of subplans that require REWIND */
112 
113  /* "flat" rangetable for executor */
115 
116  /* "flat" list of RTEPermissionInfos */
118 
119  /* "flat" list of PlanRowMarks */
121 
122  /* "flat" list of integer RT indexes */
124 
125  /* "flat" list of AppendRelInfos */
127 
128  /* List of PartitionPruneInfo contained in the plan */
130 
131  /* OIDs of relations the plan depends on */
133 
134  /* other dependencies, as PlanInvalItems */
136 
137  /* type OIDs for PARAM_EXEC Params */
139 
140  /* highest PlaceHolderVar ID assigned */
142 
143  /* highest PlanRowMark ID assigned */
145 
146  /* highest plan node ID assigned */
148 
149  /* redo plan when TransactionXmin changes? */
151 
152  /* is plan specific to current role? */
154 
155  /* parallel mode potentially OK? */
157 
158  /* parallel mode actually required? */
160 
161  /* worst PROPARALLEL hazard level */
163 
164  /* partition descriptors */
165  PartitionDirectory partition_directory pg_node_attr(read_write_ignore);
167 
168 /* macro for fetching the Plan associated with a SubPlan node */
169 #define planner_subplan_get_plan(root, subplan) \
170  ((Plan *) list_nth((root)->glob->subplans, (subplan)->plan_id - 1))
171 
172 
173 /*----------
174  * PlannerInfo
175  * Per-query information for planning/optimization
176  *
177  * This struct is conventionally called "root" in all the planner routines.
178  * It holds links to all of the planner's working state, in addition to the
179  * original Query. Note that at present the planner extensively modifies
180  * the passed-in Query data structure; someday that should stop.
181  *
182  * For reasons explained in optimizer/optimizer.h, we define the typedef
183  * either here or in that header, whichever is read first.
184  *
185  * Not all fields are printed. (In some cases, there is no print support for
186  * the field type; in others, doing so would lead to infinite recursion or
187  * bloat dump output more than seems useful.)
188  *----------
189  */
190 #ifndef HAVE_PLANNERINFO_TYPEDEF
191 typedef struct PlannerInfo PlannerInfo;
192 #define HAVE_PLANNERINFO_TYPEDEF 1
193 #endif
194 
196 {
197  pg_node_attr(no_copy_equal, no_read)
198 
199  NodeTag type;
200 
201  /* the Query being planned */
203 
204  /* global info for current planner run */
206 
207  /* 1 at the outermost Query */
209 
210  /* NULL at outermost Query */
211  PlannerInfo *parent_root pg_node_attr(read_write_ignore);
212 
213  /*
214  * plan_params contains the expressions that this query level needs to
215  * make available to a lower query level that is currently being planned.
216  * outer_params contains the paramIds of PARAM_EXEC Params that outer
217  * query levels will make available to this query level.
218  */
219  /* list of PlannerParamItems, see below */
222 
223  /*
224  * simple_rel_array holds pointers to "base rels" and "other rels" (see
225  * comments for RelOptInfo for more info). It is indexed by rangetable
226  * index (so entry 0 is always wasted). Entries can be NULL when an RTE
227  * does not correspond to a base relation, such as a join RTE or an
228  * unreferenced view RTE; or if the RelOptInfo hasn't been made yet.
229  */
230  struct RelOptInfo **simple_rel_array pg_node_attr(array_size(simple_rel_array_size));
231  /* allocated size of array */
233 
234  /*
235  * simple_rte_array is the same length as simple_rel_array and holds
236  * pointers to the associated rangetable entries. Using this is a shade
237  * faster than using rt_fetch(), mostly due to fewer indirections. (Not
238  * printed because it'd be redundant with parse->rtable.)
239  */
240  RangeTblEntry **simple_rte_array pg_node_attr(read_write_ignore);
241 
242  /*
243  * append_rel_array is the same length as the above arrays, and holds
244  * pointers to the corresponding AppendRelInfo entry indexed by
245  * child_relid, or NULL if the rel is not an appendrel child. The array
246  * itself is not allocated if append_rel_list is empty. (Not printed
247  * because it'd be redundant with append_rel_list.)
248  */
249  struct AppendRelInfo **append_rel_array pg_node_attr(read_write_ignore);
250 
251  /*
252  * all_baserels is a Relids set of all base relids (but not joins or
253  * "other" rels) in the query. This is computed in deconstruct_jointree.
254  */
256 
257  /*
258  * outer_join_rels is a Relids set of all outer-join relids in the query.
259  * This is computed in deconstruct_jointree.
260  */
262 
263  /*
264  * all_query_rels is a Relids set of all base relids and outer join relids
265  * (but not "other" relids) in the query. This is the Relids identifier
266  * of the final join we need to form. This is computed in
267  * deconstruct_jointree.
268  */
270 
271  /*
272  * join_rel_list is a list of all join-relation RelOptInfos we have
273  * considered in this planning run. For small problems we just scan the
274  * list to do lookups, but when there are many join relations we build a
275  * hash table for faster lookups. The hash table is present and valid
276  * when join_rel_hash is not NULL. Note that we still maintain the list
277  * even when using the hash table for lookups; this simplifies life for
278  * GEQO.
279  */
281  struct HTAB *join_rel_hash pg_node_attr(read_write_ignore);
282 
283  /*
284  * When doing a dynamic-programming-style join search, join_rel_level[k]
285  * is a list of all join-relation RelOptInfos of level k, and
286  * join_cur_level is the current level. New join-relation RelOptInfos are
287  * automatically added to the join_rel_level[join_cur_level] list.
288  * join_rel_level is NULL if not in use.
289  *
290  * Note: we've already printed all baserel and joinrel RelOptInfos above,
291  * so we don't dump join_rel_level or other lists of RelOptInfos.
292  */
293  /* lists of join-relation RelOptInfos */
294  List **join_rel_level pg_node_attr(read_write_ignore);
295  /* index of list being extended */
297 
298  /* init SubPlans for query */
300 
301  /*
302  * per-CTE-item list of subplan IDs (or -1 if no subplan was made for that
303  * CTE)
304  */
306 
307  /* List of Lists of Params for MULTIEXPR subquery outputs */
309 
310  /* list of JoinDomains used in the query (higher ones first) */
312 
313  /* list of active EquivalenceClasses */
315 
316  /* set true once ECs are canonical */
318 
319  /* list of "canonical" PathKeys */
321 
322  /*
323  * list of OuterJoinClauseInfos for mergejoinable outer join clauses
324  * w/nonnullable var on left
325  */
327 
328  /*
329  * list of OuterJoinClauseInfos for mergejoinable outer join clauses
330  * w/nonnullable var on right
331  */
333 
334  /*
335  * list of OuterJoinClauseInfos for mergejoinable full join clauses
336  */
338 
339  /* list of SpecialJoinInfos */
341 
342  /* counter for assigning RestrictInfo serial numbers */
344 
345  /*
346  * all_result_relids is empty for SELECT, otherwise it contains at least
347  * parse->resultRelation. For UPDATE/DELETE/MERGE across an inheritance
348  * or partitioning tree, the result rel's child relids are added. When
349  * using multi-level partitioning, intermediate partitioned rels are
350  * included. leaf_result_relids is similar except that only actual result
351  * tables, not partitioned tables, are included in it.
352  */
353  /* set of all result relids */
355  /* set of all leaf relids */
357 
358  /*
359  * list of AppendRelInfos
360  *
361  * Note: for AppendRelInfos describing partitions of a partitioned table,
362  * we guarantee that partitions that come earlier in the partitioned
363  * table's PartitionDesc will appear earlier in append_rel_list.
364  */
366 
367  /* list of RowIdentityVarInfos */
369 
370  /* list of PlanRowMarks */
372 
373  /* list of PlaceHolderInfos */
375 
376  /* array of PlaceHolderInfos indexed by phid */
377  struct PlaceHolderInfo **placeholder_array pg_node_attr(read_write_ignore, array_size(placeholder_array_size));
378  /* allocated size of array */
379  int placeholder_array_size pg_node_attr(read_write_ignore);
380 
381  /* list of ForeignKeyOptInfos */
383 
384  /* desired pathkeys for query_planner() */
386 
387  /* groupClause pathkeys, if any */
389 
390  /*
391  * The number of elements in the group_pathkeys list which belong to the
392  * GROUP BY clause. Additional ones belong to ORDER BY / DISTINCT
393  * aggregates.
394  */
396 
397  /* pathkeys of bottom window, if any */
399  /* distinctClause pathkeys, if any */
401  /* sortClause pathkeys, if any */
403 
404  /* Canonicalised partition schemes used in the query. */
405  List *part_schemes pg_node_attr(read_write_ignore);
406 
407  /* RelOptInfos we are now trying to join */
408  List *initial_rels pg_node_attr(read_write_ignore);
409 
410  /*
411  * Upper-rel RelOptInfos. Use fetch_upper_rel() to get any particular
412  * upper rel.
413  */
414  List *upper_rels[UPPERREL_FINAL + 1] pg_node_attr(read_write_ignore);
415 
416  /* Result tlists chosen by grouping_planner for upper-stage processing */
417  struct PathTarget *upper_targets[UPPERREL_FINAL + 1] pg_node_attr(read_write_ignore);
418 
419  /*
420  * The fully-processed groupClause is kept here. It differs from
421  * parse->groupClause in that we remove any items that we can prove
422  * redundant, so that only the columns named here actually need to be
423  * compared to determine grouping. Note that it's possible for *all* the
424  * items to be proven redundant, implying that there is only one group
425  * containing all the query's rows. Hence, if you want to check whether
426  * GROUP BY was specified, test for nonempty parse->groupClause, not for
427  * nonempty processed_groupClause.
428  *
429  * Currently, when grouping sets are specified we do not attempt to
430  * optimize the groupClause, so that processed_groupClause will be
431  * identical to parse->groupClause.
432  */
434 
435  /*
436  * The fully-processed distinctClause is kept here. It differs from
437  * parse->distinctClause in that we remove any items that we can prove
438  * redundant, so that only the columns named here actually need to be
439  * compared to determine uniqueness. Note that it's possible for *all*
440  * the items to be proven redundant, implying that there should be only
441  * one output row. Hence, if you want to check whether DISTINCT was
442  * specified, test for nonempty parse->distinctClause, not for nonempty
443  * processed_distinctClause.
444  */
446 
447  /*
448  * The fully-processed targetlist is kept here. It differs from
449  * parse->targetList in that (for INSERT) it's been reordered to match the
450  * target table, and defaults have been filled in. Also, additional
451  * resjunk targets may be present. preprocess_targetlist() does most of
452  * that work, but note that more resjunk targets can get added during
453  * appendrel expansion. (Hence, upper_targets mustn't get set up till
454  * after that.)
455  */
457 
458  /*
459  * For UPDATE, this list contains the target table's attribute numbers to
460  * which the first N entries of processed_tlist are to be assigned. (Any
461  * additional entries in processed_tlist must be resjunk.) DO NOT use the
462  * resnos in processed_tlist to identify the UPDATE target columns.
463  */
465 
466  /*
467  * Fields filled during create_plan() for use in setrefs.c
468  */
469  /* for GroupingFunc fixup (can't print: array length not known here) */
470  AttrNumber *grouping_map pg_node_attr(read_write_ignore);
471  /* List of MinMaxAggInfos */
473 
474  /* context holding PlannerInfo */
475  MemoryContext planner_cxt pg_node_attr(read_write_ignore);
476 
477  /* # of pages in all non-dummy tables of query */
479 
480  /* tuple_fraction passed to query_planner */
482  /* limit_tuples passed to query_planner */
484 
485  /*
486  * Minimum security_level for quals. Note: qual_security_level is zero if
487  * there are no securityQuals.
488  */
490 
491  /* true if any RTEs are RTE_JOIN kind */
493  /* true if any RTEs are marked LATERAL */
495  /* true if havingQual was non-null */
497  /* true if any RestrictInfo has pseudoconstant = true */
499  /* true if we've made any of those */
501  /* true once we're no longer allowed to add PlaceHolderInfos */
503  /* true if planning a recursive WITH item */
505 
506  /*
507  * Information about aggregates. Filled by preprocess_aggrefs().
508  */
509  /* AggInfo structs */
511  /* AggTransInfo structs */
513  /* number of aggs with DISTINCT/ORDER BY/WITHIN GROUP */
515  /* does any agg not support partial mode? */
517  /* is any partial agg non-serializable? */
519 
520  /*
521  * These fields are used only when hasRecursion is true:
522  */
523  /* PARAM_EXEC ID for the work table */
525  /* a path for non-recursive term */
527 
528  /*
529  * These fields are workspace for createplan.c
530  */
531  /* outer rels above current node */
533  /* not-yet-assigned NestLoopParams */
535 
536  /*
537  * These fields are workspace for setrefs.c. Each is an array
538  * corresponding to glob->subplans. (We could probably teach
539  * gen_node_support.pl how to determine the array length, but it doesn't
540  * seem worth the trouble, so just mark them read_write_ignore.)
541  */
542  bool *isAltSubplan pg_node_attr(read_write_ignore);
543  bool *isUsedSubplan pg_node_attr(read_write_ignore);
544 
545  /* optional private data for join_search_hook, e.g., GEQO */
546  void *join_search_private pg_node_attr(read_write_ignore);
547 
548  /* Does this query modify any partition key columns? */
550 
551  /* PartitionPruneInfos added in this query's plan. */
553 };
554 
555 
556 /*
557  * In places where it's known that simple_rte_array[] must have been prepared
558  * already, we just index into it to fetch RTEs. In code that might be
559  * executed before or after entering query_planner(), use this macro.
560  */
561 #define planner_rt_fetch(rti, root) \
562  ((root)->simple_rte_array ? (root)->simple_rte_array[rti] : \
563  rt_fetch(rti, (root)->parse->rtable))
564 
565 /*
566  * If multiple relations are partitioned the same way, all such partitions
567  * will have a pointer to the same PartitionScheme. A list of PartitionScheme
568  * objects is attached to the PlannerInfo. By design, the partition scheme
569  * incorporates only the general properties of the partition method (LIST vs.
570  * RANGE, number of partitioning columns and the type information for each)
571  * and not the specific bounds.
572  *
573  * We store the opclass-declared input data types instead of the partition key
574  * datatypes since the former rather than the latter are used to compare
575  * partition bounds. Since partition key data types and the opclass declared
576  * input data types are expected to be binary compatible (per ResolveOpClass),
577  * both of those should have same byval and length properties.
578  */
579 typedef struct PartitionSchemeData
580 {
581  char strategy; /* partition strategy */
582  int16 partnatts; /* number of partition attributes */
583  Oid *partopfamily; /* OIDs of operator families */
584  Oid *partopcintype; /* OIDs of opclass declared input data types */
585  Oid *partcollation; /* OIDs of partitioning collations */
586 
587  /* Cached information about partition key data types. */
590 
591  /* Cached information about partition comparison functions. */
594 
596 
597 /*----------
598  * RelOptInfo
599  * Per-relation information for planning/optimization
600  *
601  * For planning purposes, a "base rel" is either a plain relation (a table)
602  * or the output of a sub-SELECT or function that appears in the range table.
603  * In either case it is uniquely identified by an RT index. A "joinrel"
604  * is the joining of two or more base rels. A joinrel is identified by
605  * the set of RT indexes for its component baserels, along with RT indexes
606  * for any outer joins it has computed. We create RelOptInfo nodes for each
607  * baserel and joinrel, and store them in the PlannerInfo's simple_rel_array
608  * and join_rel_list respectively.
609  *
610  * Note that there is only one joinrel for any given set of component
611  * baserels, no matter what order we assemble them in; so an unordered
612  * set is the right datatype to identify it with.
613  *
614  * We also have "other rels", which are like base rels in that they refer to
615  * single RT indexes; but they are not part of the join tree, and are given
616  * a different RelOptKind to identify them.
617  * Currently the only kind of otherrels are those made for member relations
618  * of an "append relation", that is an inheritance set or UNION ALL subquery.
619  * An append relation has a parent RTE that is a base rel, which represents
620  * the entire append relation. The member RTEs are otherrels. The parent
621  * is present in the query join tree but the members are not. The member
622  * RTEs and otherrels are used to plan the scans of the individual tables or
623  * subqueries of the append set; then the parent baserel is given Append
624  * and/or MergeAppend paths comprising the best paths for the individual
625  * member rels. (See comments for AppendRelInfo for more information.)
626  *
627  * At one time we also made otherrels to represent join RTEs, for use in
628  * handling join alias Vars. Currently this is not needed because all join
629  * alias Vars are expanded to non-aliased form during preprocess_expression.
630  *
631  * We also have relations representing joins between child relations of
632  * different partitioned tables. These relations are not added to
633  * join_rel_level lists as they are not joined directly by the dynamic
634  * programming algorithm.
635  *
636  * There is also a RelOptKind for "upper" relations, which are RelOptInfos
637  * that describe post-scan/join processing steps, such as aggregation.
638  * Many of the fields in these RelOptInfos are meaningless, but their Path
639  * fields always hold Paths showing ways to do that processing step.
640  *
641  * Lastly, there is a RelOptKind for "dead" relations, which are base rels
642  * that we have proven we don't need to join after all.
643  *
644  * Parts of this data structure are specific to various scan and join
645  * mechanisms. It didn't seem worth creating new node types for them.
646  *
647  * relids - Set of relation identifiers (RT indexes). This is a base
648  * relation if there is just one, a join relation if more;
649  * in the join case, RT indexes of any outer joins formed
650  * at or below this join are included along with baserels
651  * rows - estimated number of tuples in the relation after restriction
652  * clauses have been applied (ie, output rows of a plan for it)
653  * consider_startup - true if there is any value in keeping plain paths for
654  * this rel on the basis of having cheap startup cost
655  * consider_param_startup - the same for parameterized paths
656  * reltarget - Default Path output tlist for this rel; normally contains
657  * Var and PlaceHolderVar nodes for the values we need to
658  * output from this relation.
659  * List is in no particular order, but all rels of an
660  * appendrel set must use corresponding orders.
661  * NOTE: in an appendrel child relation, may contain
662  * arbitrary expressions pulled up from a subquery!
663  * pathlist - List of Path nodes, one for each potentially useful
664  * method of generating the relation
665  * ppilist - ParamPathInfo nodes for parameterized Paths, if any
666  * cheapest_startup_path - the pathlist member with lowest startup cost
667  * (regardless of ordering) among the unparameterized paths;
668  * or NULL if there is no unparameterized path
669  * cheapest_total_path - the pathlist member with lowest total cost
670  * (regardless of ordering) among the unparameterized paths;
671  * or if there is no unparameterized path, the path with lowest
672  * total cost among the paths with minimum parameterization
673  * cheapest_unique_path - for caching cheapest path to produce unique
674  * (no duplicates) output from relation; NULL if not yet requested
675  * cheapest_parameterized_paths - best paths for their parameterizations;
676  * always includes cheapest_total_path, even if that's unparameterized
677  * direct_lateral_relids - rels this rel has direct LATERAL references to
678  * lateral_relids - required outer rels for LATERAL, as a Relids set
679  * (includes both direct and indirect lateral references)
680  *
681  * If the relation is a base relation it will have these fields set:
682  *
683  * relid - RTE index (this is redundant with the relids field, but
684  * is provided for convenience of access)
685  * rtekind - copy of RTE's rtekind field
686  * min_attr, max_attr - range of valid AttrNumbers for rel
687  * attr_needed - array of bitmapsets indicating the highest joinrel
688  * in which each attribute is needed; if bit 0 is set then
689  * the attribute is needed as part of final targetlist
690  * attr_widths - cache space for per-attribute width estimates;
691  * zero means not computed yet
692  * nulling_relids - relids of outer joins that can null this rel
693  * lateral_vars - lateral cross-references of rel, if any (list of
694  * Vars and PlaceHolderVars)
695  * lateral_referencers - relids of rels that reference this one laterally
696  * (includes both direct and indirect lateral references)
697  * indexlist - list of IndexOptInfo nodes for relation's indexes
698  * (always NIL if it's not a table or partitioned table)
699  * pages - number of disk pages in relation (zero if not a table)
700  * tuples - number of tuples in relation (not considering restrictions)
701  * allvisfrac - fraction of disk pages that are marked all-visible
702  * eclass_indexes - EquivalenceClasses that mention this rel (filled
703  * only after EC merging is complete)
704  * subroot - PlannerInfo for subquery (NULL if it's not a subquery)
705  * subplan_params - list of PlannerParamItems to be passed to subquery
706  *
707  * Note: for a subquery, tuples and subroot are not set immediately
708  * upon creation of the RelOptInfo object; they are filled in when
709  * set_subquery_pathlist processes the object.
710  *
711  * For otherrels that are appendrel members, these fields are filled
712  * in just as for a baserel, except we don't bother with lateral_vars.
713  *
714  * If the relation is either a foreign table or a join of foreign tables that
715  * all belong to the same foreign server and are assigned to the same user to
716  * check access permissions as (cf checkAsUser), these fields will be set:
717  *
718  * serverid - OID of foreign server, if foreign table (else InvalidOid)
719  * userid - OID of user to check access as (InvalidOid means current user)
720  * useridiscurrent - we've assumed that userid equals current user
721  * fdwroutine - function hooks for FDW, if foreign table (else NULL)
722  * fdw_private - private state for FDW, if foreign table (else NULL)
723  *
724  * Two fields are used to cache knowledge acquired during the join search
725  * about whether this rel is provably unique when being joined to given other
726  * relation(s), ie, it can have at most one row matching any given row from
727  * that join relation. Currently we only attempt such proofs, and thus only
728  * populate these fields, for base rels; but someday they might be used for
729  * join rels too:
730  *
731  * unique_for_rels - list of Relid sets, each one being a set of other
732  * rels for which this one has been proven unique
733  * non_unique_for_rels - list of Relid sets, each one being a set of
734  * other rels for which we have tried and failed to prove
735  * this one unique
736  *
737  * The presence of the following fields depends on the restrictions
738  * and joins that the relation participates in:
739  *
740  * baserestrictinfo - List of RestrictInfo nodes, containing info about
741  * each non-join qualification clause in which this relation
742  * participates (only used for base rels)
743  * baserestrictcost - Estimated cost of evaluating the baserestrictinfo
744  * clauses at a single tuple (only used for base rels)
745  * baserestrict_min_security - Smallest security_level found among
746  * clauses in baserestrictinfo
747  * joininfo - List of RestrictInfo nodes, containing info about each
748  * join clause in which this relation participates (but
749  * note this excludes clauses that might be derivable from
750  * EquivalenceClasses)
751  * has_eclass_joins - flag that EquivalenceClass joins are possible
752  *
753  * Note: Keeping a restrictinfo list in the RelOptInfo is useful only for
754  * base rels, because for a join rel the set of clauses that are treated as
755  * restrict clauses varies depending on which sub-relations we choose to join.
756  * (For example, in a 3-base-rel join, a clause relating rels 1 and 2 must be
757  * treated as a restrictclause if we join {1} and {2 3} to make {1 2 3}; but
758  * if we join {1 2} and {3} then that clause will be a restrictclause in {1 2}
759  * and should not be processed again at the level of {1 2 3}.) Therefore,
760  * the restrictinfo list in the join case appears in individual JoinPaths
761  * (field joinrestrictinfo), not in the parent relation. But it's OK for
762  * the RelOptInfo to store the joininfo list, because that is the same
763  * for a given rel no matter how we form it.
764  *
765  * We store baserestrictcost in the RelOptInfo (for base relations) because
766  * we know we will need it at least once (to price the sequential scan)
767  * and may need it multiple times to price index scans.
768  *
769  * A join relation is considered to be partitioned if it is formed from a
770  * join of two relations that are partitioned, have matching partitioning
771  * schemes, and are joined on an equijoin of the partitioning columns.
772  * Under those conditions we can consider the join relation to be partitioned
773  * by either relation's partitioning keys, though some care is needed if
774  * either relation can be forced to null by outer-joining. For example, an
775  * outer join like (A LEFT JOIN B ON A.a = B.b) may produce rows with B.b
776  * NULL. These rows may not fit the partitioning conditions imposed on B.
777  * Hence, strictly speaking, the join is not partitioned by B.b and thus
778  * partition keys of an outer join should include partition key expressions
779  * from the non-nullable side only. However, if a subsequent join uses
780  * strict comparison operators (and all commonly-used equijoin operators are
781  * strict), the presence of nulls doesn't cause a problem: such rows couldn't
782  * match anything on the other side and thus they don't create a need to do
783  * any cross-partition sub-joins. Hence we can treat such values as still
784  * partitioning the join output for the purpose of additional partitionwise
785  * joining, so long as a strict join operator is used by the next join.
786  *
787  * If the relation is partitioned, these fields will be set:
788  *
789  * part_scheme - Partitioning scheme of the relation
790  * nparts - Number of partitions
791  * boundinfo - Partition bounds
792  * partbounds_merged - true if partition bounds are merged ones
793  * partition_qual - Partition constraint if not the root
794  * part_rels - RelOptInfos for each partition
795  * all_partrels - Relids set of all partition relids
796  * partexprs, nullable_partexprs - Partition key expressions
797  *
798  * The partexprs and nullable_partexprs arrays each contain
799  * part_scheme->partnatts elements. Each of the elements is a list of
800  * partition key expressions. For partitioned base relations, there is one
801  * expression in each partexprs element, and nullable_partexprs is empty.
802  * For partitioned join relations, each base relation within the join
803  * contributes one partition key expression per partitioning column;
804  * that expression goes in the partexprs[i] list if the base relation
805  * is not nullable by this join or any lower outer join, or in the
806  * nullable_partexprs[i] list if the base relation is nullable.
807  * Furthermore, FULL JOINs add extra nullable_partexprs expressions
808  * corresponding to COALESCE expressions of the left and right join columns,
809  * to simplify matching join clauses to those lists.
810  *
811  * Not all fields are printed. (In some cases, there is no print support for
812  * the field type.)
813  *----------
814  */
815 
816 /* Bitmask of flags supported by table AMs */
817 #define AMFLAG_HAS_TID_RANGE (1 << 0)
818 
819 typedef enum RelOptKind
820 {
829 
830 /*
831  * Is the given relation a simple relation i.e a base or "other" member
832  * relation?
833  */
834 #define IS_SIMPLE_REL(rel) \
835  ((rel)->reloptkind == RELOPT_BASEREL || \
836  (rel)->reloptkind == RELOPT_OTHER_MEMBER_REL)
837 
838 /* Is the given relation a join relation? */
839 #define IS_JOIN_REL(rel) \
840  ((rel)->reloptkind == RELOPT_JOINREL || \
841  (rel)->reloptkind == RELOPT_OTHER_JOINREL)
842 
843 /* Is the given relation an upper relation? */
844 #define IS_UPPER_REL(rel) \
845  ((rel)->reloptkind == RELOPT_UPPER_REL || \
846  (rel)->reloptkind == RELOPT_OTHER_UPPER_REL)
847 
848 /* Is the given relation an "other" relation? */
849 #define IS_OTHER_REL(rel) \
850  ((rel)->reloptkind == RELOPT_OTHER_MEMBER_REL || \
851  (rel)->reloptkind == RELOPT_OTHER_JOINREL || \
852  (rel)->reloptkind == RELOPT_OTHER_UPPER_REL)
853 
854 typedef struct RelOptInfo
855 {
856  pg_node_attr(no_copy_equal, no_read)
857 
858  NodeTag type;
859 
861 
862  /*
863  * all relations included in this RelOptInfo; set of base + OJ relids
864  * (rangetable indexes)
865  */
867 
868  /*
869  * size estimates generated by planner
870  */
871  /* estimated number of result tuples */
873 
874  /*
875  * per-relation planner control flags
876  */
877  /* keep cheap-startup-cost paths? */
879  /* ditto, for parameterized paths? */
881  /* consider parallel paths? */
883 
884  /*
885  * default result targetlist for Paths scanning this relation; list of
886  * Vars/Exprs, cost, width
887  */
889 
890  /*
891  * materialization information
892  */
893  List *pathlist; /* Path structures */
894  List *ppilist; /* ParamPathInfos used in pathlist */
895  List *partial_pathlist; /* partial Paths */
900 
901  /*
902  * parameterization information needed for both base rels and join rels
903  * (see also lateral_vars and lateral_referencers)
904  */
905  /* rels directly laterally referenced */
907  /* minimum parameterization of rel */
909 
910  /*
911  * information about a base rel (not set for join rels!)
912  */
914  /* containing tablespace */
916  /* RELATION, SUBQUERY, FUNCTION, etc */
918  /* smallest attrno of rel (often <0) */
920  /* largest attrno of rel */
922  /* array indexed [min_attr .. max_attr] */
923  Relids *attr_needed pg_node_attr(read_write_ignore);
924  /* array indexed [min_attr .. max_attr] */
925  int32 *attr_widths pg_node_attr(read_write_ignore);
926  /* relids of outer joins that can null this baserel */
928  /* LATERAL Vars and PHVs referenced by rel */
930  /* rels that reference this baserel laterally */
932  /* list of IndexOptInfo */
934  /* list of StatisticExtInfo */
936  /* size estimates derived from pg_class */
939  double allvisfrac;
940  /* indexes in PlannerInfo's eq_classes list of ECs that mention this rel */
942  PlannerInfo *subroot; /* if subquery */
943  List *subplan_params; /* if subquery */
944  /* wanted number of parallel workers */
946  /* Bitmask of optional features supported by the table AM */
948 
949  /*
950  * Information about foreign tables and foreign joins
951  */
952  /* identifies server for the table or join */
954  /* identifies user to check access as; 0 means to check as current user */
956  /* join is only valid for current user */
958  /* use "struct FdwRoutine" to avoid including fdwapi.h here */
959  struct FdwRoutine *fdwroutine pg_node_attr(read_write_ignore);
960  void *fdw_private pg_node_attr(read_write_ignore);
961 
962  /*
963  * cache space for remembering if we have proven this relation unique
964  */
965  /* known unique for these other relid set(s) */
967  /* known not unique for these set(s) */
969 
970  /*
971  * used by various scans and joins:
972  */
973  /* RestrictInfo structures (if base rel) */
975  /* cost of evaluating the above */
977  /* min security_level found in baserestrictinfo */
979  /* RestrictInfo structures for join clauses involving this rel */
981  /* T means joininfo is incomplete */
983 
984  /*
985  * used by partitionwise joins:
986  */
987  /* consider partitionwise join paths? (if partitioned rel) */
989 
990  /*
991  * inheritance links, if this is an otherrel (otherwise NULL):
992  */
993  /* Immediate parent relation (dumping it would be too verbose) */
994  struct RelOptInfo *parent pg_node_attr(read_write_ignore);
995  /* Topmost parent relation (dumping it would be too verbose) */
996  struct RelOptInfo *top_parent pg_node_attr(read_write_ignore);
997  /* Relids of topmost parent (redundant, but handy) */
999 
1000  /*
1001  * used for partitioned relations:
1002  */
1003  /* Partitioning scheme */
1004  PartitionScheme part_scheme pg_node_attr(read_write_ignore);
1005 
1006  /*
1007  * Number of partitions; -1 if not yet set; in case of a join relation 0
1008  * means it's considered unpartitioned
1009  */
1010  int nparts;
1011  /* Partition bounds */
1012  struct PartitionBoundInfoData *boundinfo pg_node_attr(read_write_ignore);
1013  /* True if partition bounds were created by partition_bounds_merge() */
1015  /* Partition constraint, if not the root */
1017 
1018  /*
1019  * Array of RelOptInfos of partitions, stored in the same order as bounds
1020  * (don't print, too bulky and duplicative)
1021  */
1022  struct RelOptInfo **part_rels pg_node_attr(read_write_ignore);
1023 
1024  /*
1025  * Bitmap with members acting as indexes into the part_rels[] array to
1026  * indicate which partitions survived partition pruning.
1027  */
1029  /* Relids set of all partition relids */
1031 
1032  /*
1033  * These arrays are of length partkey->partnatts, which we don't have at
1034  * hand, so don't try to print
1035  */
1036 
1037  /* Non-nullable partition key expressions */
1038  List **partexprs pg_node_attr(read_write_ignore);
1039  /* Nullable partition key expressions */
1040  List **nullable_partexprs pg_node_attr(read_write_ignore);
1042 
1043 /*
1044  * Is given relation partitioned?
1045  *
1046  * It's not enough to test whether rel->part_scheme is set, because it might
1047  * be that the basic partitioning properties of the input relations matched
1048  * but the partition bounds did not. Also, if we are able to prove a rel
1049  * dummy (empty), we should henceforth treat it as unpartitioned.
1050  */
1051 #define IS_PARTITIONED_REL(rel) \
1052  ((rel)->part_scheme && (rel)->boundinfo && (rel)->nparts > 0 && \
1053  (rel)->part_rels && !IS_DUMMY_REL(rel))
1054 
1055 /*
1056  * Convenience macro to make sure that a partitioned relation has all the
1057  * required members set.
1058  */
1059 #define REL_HAS_ALL_PART_PROPS(rel) \
1060  ((rel)->part_scheme && (rel)->boundinfo && (rel)->nparts > 0 && \
1061  (rel)->part_rels && (rel)->partexprs && (rel)->nullable_partexprs)
1062 
1063 /*
1064  * IndexOptInfo
1065  * Per-index information for planning/optimization
1066  *
1067  * indexkeys[], indexcollations[] each have ncolumns entries.
1068  * opfamily[], and opcintype[] each have nkeycolumns entries. They do
1069  * not contain any information about included attributes.
1070  *
1071  * sortopfamily[], reverse_sort[], and nulls_first[] have
1072  * nkeycolumns entries, if the index is ordered; but if it is unordered,
1073  * those pointers are NULL.
1074  *
1075  * Zeroes in the indexkeys[] array indicate index columns that are
1076  * expressions; there is one element in indexprs for each such column.
1077  *
1078  * For an ordered index, reverse_sort[] and nulls_first[] describe the
1079  * sort ordering of a forward indexscan; we can also consider a backward
1080  * indexscan, which will generate the reverse ordering.
1081  *
1082  * The indexprs and indpred expressions have been run through
1083  * prepqual.c and eval_const_expressions() for ease of matching to
1084  * WHERE clauses. indpred is in implicit-AND form.
1085  *
1086  * indextlist is a TargetEntry list representing the index columns.
1087  * It provides an equivalent base-relation Var for each simple column,
1088  * and links to the matching indexprs element for each expression column.
1089  *
1090  * While most of these fields are filled when the IndexOptInfo is created
1091  * (by plancat.c), indrestrictinfo and predOK are set later, in
1092  * check_index_predicates().
1093  */
1094 #ifndef HAVE_INDEXOPTINFO_TYPEDEF
1095 typedef struct IndexOptInfo IndexOptInfo;
1096 #define HAVE_INDEXOPTINFO_TYPEDEF 1
1097 #endif
1098 
1100 {
1101  pg_node_attr(no_copy_equal, no_read)
1102 
1103  NodeTag type;
1104 
1105  /* OID of the index relation */
1107  /* tablespace of index (not table) */
1109  /* back-link to index's table; don't print, else infinite recursion */
1110  RelOptInfo *rel pg_node_attr(read_write_ignore);
1111 
1112  /*
1113  * index-size statistics (from pg_class and elsewhere)
1114  */
1115  /* number of disk pages in index */
1117  /* number of index tuples in index */
1119  /* index tree height, or -1 if unknown */
1121 
1122  /*
1123  * index descriptor information
1124  */
1125  /* number of columns in index */
1127  /* number of key columns in index */
1129 
1130  /*
1131  * table column numbers of index's columns (both key and included
1132  * columns), or 0 for expression columns
1133  */
1134  int *indexkeys pg_node_attr(array_size(ncolumns));
1135  /* OIDs of collations of index columns */
1136  Oid *indexcollations pg_node_attr(array_size(nkeycolumns));
1137  /* OIDs of operator families for columns */
1138  Oid *opfamily pg_node_attr(array_size(nkeycolumns));
1139  /* OIDs of opclass declared input data types */
1140  Oid *opcintype pg_node_attr(array_size(nkeycolumns));
1141  /* OIDs of btree opfamilies, if orderable. NULL if partitioned index */
1142  Oid *sortopfamily pg_node_attr(array_size(nkeycolumns));
1143  /* is sort order descending? or NULL if partitioned index */
1144  bool *reverse_sort pg_node_attr(array_size(nkeycolumns));
1145  /* do NULLs come first in the sort order? or NULL if partitioned index */
1146  bool *nulls_first pg_node_attr(array_size(nkeycolumns));
1147  /* opclass-specific options for columns */
1148  bytea **opclassoptions pg_node_attr(read_write_ignore);
1149  /* which index cols can be returned in an index-only scan? */
1150  bool *canreturn pg_node_attr(array_size(ncolumns));
1151  /* OID of the access method (in pg_am) */
1153 
1154  /*
1155  * expressions for non-simple index columns; redundant to print since we
1156  * print indextlist
1157  */
1158  List *indexprs pg_node_attr(read_write_ignore);
1159  /* predicate if a partial index, else NIL */
1161 
1162  /* targetlist representing index columns */
1164 
1165  /*
1166  * parent relation's baserestrictinfo list, less any conditions implied by
1167  * the index's predicate (unless it's a target rel, see comments in
1168  * check_index_predicates())
1169  */
1171 
1172  /* true if index predicate matches query */
1173  bool predOK;
1174  /* true if a unique index */
1175  bool unique;
1176  /* is uniqueness enforced immediately? */
1178  /* true if index doesn't really exist */
1180 
1181  /*
1182  * Remaining fields are copied from the index AM's API struct
1183  * (IndexAmRoutine). These fields are not set for partitioned indexes.
1184  */
1189  /* does AM have amgettuple interface? */
1191  /* does AM have amgetbitmap interface? */
1194  /* does AM have ammarkpos interface? */
1196  /* AM's cost estimator */
1197  /* Rather than include amapi.h here, we declare amcostestimate like this */
1198  void (*amcostestimate) () pg_node_attr(read_write_ignore);
1199 };
1200 
1201 /*
1202  * ForeignKeyOptInfo
1203  * Per-foreign-key information for planning/optimization
1204  *
1205  * The per-FK-column arrays can be fixed-size because we allow at most
1206  * INDEX_MAX_KEYS columns in a foreign key constraint. Each array has
1207  * nkeys valid entries.
1208  */
1209 typedef struct ForeignKeyOptInfo
1210 {
1211  pg_node_attr(custom_read_write, no_copy_equal, no_read)
1212 
1213  NodeTag type;
1214 
1215  /*
1216  * Basic data about the foreign key (fetched from catalogs):
1217  */
1218 
1219  /* RT index of the referencing table */
1221  /* RT index of the referenced table */
1223  /* number of columns in the foreign key */
1224  int nkeys;
1225  /* cols in referencing table */
1227  /* cols in referenced table */
1229  /* PK = FK operator OIDs */
1230  Oid conpfeqop[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys));
1231 
1232  /*
1233  * Derived info about whether FK's equality conditions match the query:
1234  */
1235 
1236  /* # of FK cols matched by ECs */
1238  /* # of these ECs that are ec_has_const */
1240  /* # of FK cols matched by non-EC rinfos */
1242  /* total # of non-EC rinfos matched to FK */
1244  /* Pointer to eclass matching each column's condition, if there is one */
1246  /* Pointer to eclass member for the referencing Var, if there is one */
1248  /* List of non-EC RestrictInfos matching each column's condition */
1251 
1252 /*
1253  * StatisticExtInfo
1254  * Information about extended statistics for planning/optimization
1255  *
1256  * Each pg_statistic_ext row is represented by one or more nodes of this
1257  * type, or even zero if ANALYZE has not computed them.
1258  */
1259 typedef struct StatisticExtInfo
1260 {
1261  pg_node_attr(no_copy_equal, no_read)
1262 
1263  NodeTag type;
1264 
1265  /* OID of the statistics row */
1267 
1268  /* includes child relations */
1269  bool inherit;
1270 
1271  /* back-link to statistic's table; don't print, else infinite recursion */
1272  RelOptInfo *rel pg_node_attr(read_write_ignore);
1273 
1274  /* statistics kind of this entry */
1275  char kind;
1276 
1277  /* attnums of the columns covered */
1279 
1280  /* expressions */
1283 
1284 /*
1285  * JoinDomains
1286  *
1287  * A "join domain" defines the scope of applicability of deductions made via
1288  * the EquivalenceClass mechanism. Roughly speaking, a join domain is a set
1289  * of base+OJ relations that are inner-joined together. More precisely, it is
1290  * the set of relations at which equalities deduced from an EquivalenceClass
1291  * can be enforced or should be expected to hold. The topmost JoinDomain
1292  * covers the whole query (so its jd_relids should equal all_query_rels).
1293  * An outer join creates a new JoinDomain that includes all base+OJ relids
1294  * within its nullable side, but (by convention) not the OJ's own relid.
1295  * A FULL join creates two new JoinDomains, one for each side.
1296  *
1297  * Notice that a rel that is below outer join(s) will thus appear to belong
1298  * to multiple join domains. However, any of its Vars that appear in
1299  * EquivalenceClasses belonging to higher join domains will have nullingrel
1300  * bits preventing them from being evaluated at the rel's scan level, so that
1301  * we will not be able to derive enforceable-at-the-rel-scan-level clauses
1302  * from such ECs. We define the join domain relid sets this way so that
1303  * domains can be said to be "higher" or "lower" when one domain relid set
1304  * includes another.
1305  *
1306  * The JoinDomains for a query are computed in deconstruct_jointree.
1307  * We do not copy JoinDomain structs once made, so they can be compared
1308  * for equality by simple pointer equality.
1309  */
1310 typedef struct JoinDomain
1311 {
1312  pg_node_attr(no_copy_equal, no_read)
1313 
1314  NodeTag type;
1315 
1316  Relids jd_relids; /* all relids contained within the domain */
1318 
1319 /*
1320  * EquivalenceClasses
1321  *
1322  * Whenever we identify a mergejoinable equality clause A = B that is
1323  * not an outer-join clause, we create an EquivalenceClass containing
1324  * the expressions A and B to record this knowledge. If we later find another
1325  * equivalence B = C, we add C to the existing EquivalenceClass; this may
1326  * require merging two existing EquivalenceClasses. At the end of the qual
1327  * distribution process, we have sets of values that are known all transitively
1328  * equal to each other, where "equal" is according to the rules of the btree
1329  * operator family(s) shown in ec_opfamilies, as well as the collation shown
1330  * by ec_collation. (We restrict an EC to contain only equalities whose
1331  * operators belong to the same set of opfamilies. This could probably be
1332  * relaxed, but for now it's not worth the trouble, since nearly all equality
1333  * operators belong to only one btree opclass anyway. Similarly, we suppose
1334  * that all or none of the input datatypes are collatable, so that a single
1335  * collation value is sufficient.)
1336  *
1337  * Strictly speaking, deductions from an EquivalenceClass hold only within
1338  * a "join domain", that is a set of relations that are innerjoined together
1339  * (see JoinDomain above). For the most part we don't need to account for
1340  * this explicitly, because equality clauses from different join domains
1341  * will contain Vars that are not equal() because they have different
1342  * nullingrel sets, and thus we will never falsely merge ECs from different
1343  * join domains. But Var-free (pseudoconstant) expressions lack that safety
1344  * feature. We handle that by marking "const" EC members with the JoinDomain
1345  * of the clause they came from; two nominally-equal const members will be
1346  * considered different if they came from different JoinDomains. This ensures
1347  * no false EquivalenceClass merges will occur.
1348  *
1349  * We also use EquivalenceClasses as the base structure for PathKeys, letting
1350  * us represent knowledge about different sort orderings being equivalent.
1351  * Since every PathKey must reference an EquivalenceClass, we will end up
1352  * with single-member EquivalenceClasses whenever a sort key expression has
1353  * not been equivalenced to anything else. It is also possible that such an
1354  * EquivalenceClass will contain a volatile expression ("ORDER BY random()"),
1355  * which is a case that can't arise otherwise since clauses containing
1356  * volatile functions are never considered mergejoinable. We mark such
1357  * EquivalenceClasses specially to prevent them from being merged with
1358  * ordinary EquivalenceClasses. Also, for volatile expressions we have
1359  * to be careful to match the EquivalenceClass to the correct targetlist
1360  * entry: consider SELECT random() AS a, random() AS b ... ORDER BY b,a.
1361  * So we record the SortGroupRef of the originating sort clause.
1362  *
1363  * NB: if ec_merged isn't NULL, this class has been merged into another, and
1364  * should be ignored in favor of using the pointed-to class.
1365  *
1366  * NB: EquivalenceClasses are never copied after creation. Therefore,
1367  * copyObject() copies pointers to them as pointers, and equal() compares
1368  * pointers to EquivalenceClasses via pointer equality. This is implemented
1369  * by putting copy_as_scalar and equal_as_scalar attributes on fields that
1370  * are pointers to EquivalenceClasses. The same goes for EquivalenceMembers.
1371  */
1372 typedef struct EquivalenceClass
1373 {
1374  pg_node_attr(custom_read_write, no_copy_equal, no_read)
1375 
1376  NodeTag type;
1377 
1378  List *ec_opfamilies; /* btree operator family OIDs */
1379  Oid ec_collation; /* collation, if datatypes are collatable */
1380  List *ec_members; /* list of EquivalenceMembers */
1381  List *ec_sources; /* list of generating RestrictInfos */
1382  List *ec_derives; /* list of derived RestrictInfos */
1383  Relids ec_relids; /* all relids appearing in ec_members, except
1384  * for child members (see below) */
1385  bool ec_has_const; /* any pseudoconstants in ec_members? */
1386  bool ec_has_volatile; /* the (sole) member is a volatile expr */
1387  bool ec_broken; /* failed to generate needed clauses? */
1388  Index ec_sortref; /* originating sortclause label, or 0 */
1389  Index ec_min_security; /* minimum security_level in ec_sources */
1390  Index ec_max_security; /* maximum security_level in ec_sources */
1391  struct EquivalenceClass *ec_merged; /* set if merged into another EC */
1393 
1394 /*
1395  * If an EC contains a constant, any PathKey depending on it must be
1396  * redundant, since there's only one possible value of the key.
1397  */
1398 #define EC_MUST_BE_REDUNDANT(eclass) \
1399  ((eclass)->ec_has_const)
1400 
1401 /*
1402  * EquivalenceMember - one member expression of an EquivalenceClass
1403  *
1404  * em_is_child signifies that this element was built by transposing a member
1405  * for an appendrel parent relation to represent the corresponding expression
1406  * for an appendrel child. These members are used for determining the
1407  * pathkeys of scans on the child relation and for explicitly sorting the
1408  * child when necessary to build a MergeAppend path for the whole appendrel
1409  * tree. An em_is_child member has no impact on the properties of the EC as a
1410  * whole; in particular the EC's ec_relids field does NOT include the child
1411  * relation. An em_is_child member should never be marked em_is_const nor
1412  * cause ec_has_const or ec_has_volatile to be set, either. Thus, em_is_child
1413  * members are not really full-fledged members of the EC, but just reflections
1414  * or doppelgangers of real members. Most operations on EquivalenceClasses
1415  * should ignore em_is_child members, and those that don't should test
1416  * em_relids to make sure they only consider relevant members.
1417  *
1418  * em_datatype is usually the same as exprType(em_expr), but can be
1419  * different when dealing with a binary-compatible opfamily; in particular
1420  * anyarray_ops would never work without this. Use em_datatype when
1421  * looking up a specific btree operator to work with this expression.
1422  */
1423 typedef struct EquivalenceMember
1424 {
1425  pg_node_attr(no_copy_equal, no_read)
1426 
1427  NodeTag type;
1428 
1429  Expr *em_expr; /* the expression represented */
1430  Relids em_relids; /* all relids appearing in em_expr */
1431  bool em_is_const; /* expression is pseudoconstant? */
1432  bool em_is_child; /* derived version for a child relation? */
1433  Oid em_datatype; /* the "nominal type" used by the opfamily */
1434  JoinDomain *em_jdomain; /* join domain containing the source clause */
1435  /* if em_is_child is true, this links to corresponding EM for top parent */
1436  struct EquivalenceMember *em_parent pg_node_attr(read_write_ignore);
1438 
1439 /*
1440  * PathKeys
1441  *
1442  * The sort ordering of a path is represented by a list of PathKey nodes.
1443  * An empty list implies no known ordering. Otherwise the first item
1444  * represents the primary sort key, the second the first secondary sort key,
1445  * etc. The value being sorted is represented by linking to an
1446  * EquivalenceClass containing that value and including pk_opfamily among its
1447  * ec_opfamilies. The EquivalenceClass tells which collation to use, too.
1448  * This is a convenient method because it makes it trivial to detect
1449  * equivalent and closely-related orderings. (See optimizer/README for more
1450  * information.)
1451  *
1452  * Note: pk_strategy is either BTLessStrategyNumber (for ASC) or
1453  * BTGreaterStrategyNumber (for DESC). We assume that all ordering-capable
1454  * index types will use btree-compatible strategy numbers.
1455  */
1456 typedef struct PathKey
1457 {
1458  pg_node_attr(no_read)
1459 
1460  NodeTag type;
1461 
1462  /* the value that is ordered */
1463  EquivalenceClass *pk_eclass pg_node_attr(copy_as_scalar, equal_as_scalar);
1464  Oid pk_opfamily; /* btree opfamily defining the ordering */
1465  int pk_strategy; /* sort direction (ASC or DESC) */
1466  bool pk_nulls_first; /* do NULLs come before normal values? */
1468 
1469 /*
1470  * VolatileFunctionStatus -- allows nodes to cache their
1471  * contain_volatile_functions properties. VOLATILITY_UNKNOWN means not yet
1472  * determined.
1473  */
1475 {
1480 
1481 /*
1482  * PathTarget
1483  *
1484  * This struct contains what we need to know during planning about the
1485  * targetlist (output columns) that a Path will compute. Each RelOptInfo
1486  * includes a default PathTarget, which its individual Paths may simply
1487  * reference. However, in some cases a Path may compute outputs different
1488  * from other Paths, and in that case we make a custom PathTarget for it.
1489  * For example, an indexscan might return index expressions that would
1490  * otherwise need to be explicitly calculated. (Note also that "upper"
1491  * relations generally don't have useful default PathTargets.)
1492  *
1493  * exprs contains bare expressions; they do not have TargetEntry nodes on top,
1494  * though those will appear in finished Plans.
1495  *
1496  * sortgrouprefs[] is an array of the same length as exprs, containing the
1497  * corresponding sort/group refnos, or zeroes for expressions not referenced
1498  * by sort/group clauses. If sortgrouprefs is NULL (which it generally is in
1499  * RelOptInfo.reltarget targets; only upper-level Paths contain this info),
1500  * we have not identified sort/group columns in this tlist. This allows us to
1501  * deal with sort/group refnos when needed with less expense than including
1502  * TargetEntry nodes in the exprs list.
1503  */
1504 typedef struct PathTarget
1505 {
1506  pg_node_attr(no_copy_equal, no_read)
1507 
1508  NodeTag type;
1509 
1510  /* list of expressions to be computed */
1512 
1513  /* corresponding sort/group refnos, or 0 */
1514  Index *sortgrouprefs pg_node_attr(array_size(exprs));
1515 
1516  /* cost of evaluating the expressions */
1518 
1519  /* estimated avg width of result tuples */
1520  int width;
1521 
1522  /* indicates if exprs contain any volatile functions */
1525 
1526 /* Convenience macro to get a sort/group refno from a PathTarget */
1527 #define get_pathtarget_sortgroupref(target, colno) \
1528  ((target)->sortgrouprefs ? (target)->sortgrouprefs[colno] : (Index) 0)
1529 
1530 
1531 /*
1532  * ParamPathInfo
1533  *
1534  * All parameterized paths for a given relation with given required outer rels
1535  * link to a single ParamPathInfo, which stores common information such as
1536  * the estimated rowcount for this parameterization. We do this partly to
1537  * avoid recalculations, but mostly to ensure that the estimated rowcount
1538  * is in fact the same for every such path.
1539  *
1540  * Note: ppi_clauses is only used in ParamPathInfos for base relation paths;
1541  * in join cases it's NIL because the set of relevant clauses varies depending
1542  * on how the join is formed. The relevant clauses will appear in each
1543  * parameterized join path's joinrestrictinfo list, instead. ParamPathInfos
1544  * for append relations don't bother with this, either.
1545  *
1546  * ppi_serials is the set of rinfo_serial numbers for quals that are enforced
1547  * by this path. As with ppi_clauses, it's only maintained for baserels.
1548  * (We could construct it on-the-fly from ppi_clauses, but it seems better
1549  * to materialize a copy.)
1550  */
1551 typedef struct ParamPathInfo
1552 {
1553  pg_node_attr(no_copy_equal, no_read)
1554 
1555  NodeTag type;
1556 
1557  Relids ppi_req_outer; /* rels supplying parameters used by path */
1558  Cardinality ppi_rows; /* estimated number of result tuples */
1559  List *ppi_clauses; /* join clauses available from outer rels */
1560  Bitmapset *ppi_serials; /* set of rinfo_serial for enforced quals */
1562 
1563 
1564 /*
1565  * Type "Path" is used as-is for sequential-scan paths, as well as some other
1566  * simple plan types that we don't need any extra information in the path for.
1567  * For other path types it is the first component of a larger struct.
1568  *
1569  * "pathtype" is the NodeTag of the Plan node we could build from this Path.
1570  * It is partially redundant with the Path's NodeTag, but allows us to use
1571  * the same Path type for multiple Plan types when there is no need to
1572  * distinguish the Plan type during path processing.
1573  *
1574  * "parent" identifies the relation this Path scans, and "pathtarget"
1575  * describes the precise set of output columns the Path would compute.
1576  * In simple cases all Paths for a given rel share the same targetlist,
1577  * which we represent by having path->pathtarget equal to parent->reltarget.
1578  *
1579  * "param_info", if not NULL, links to a ParamPathInfo that identifies outer
1580  * relation(s) that provide parameter values to each scan of this path.
1581  * That means this path can only be joined to those rels by means of nestloop
1582  * joins with this path on the inside. Also note that a parameterized path
1583  * is responsible for testing all "movable" joinclauses involving this rel
1584  * and the specified outer rel(s).
1585  *
1586  * "rows" is the same as parent->rows in simple paths, but in parameterized
1587  * paths and UniquePaths it can be less than parent->rows, reflecting the
1588  * fact that we've filtered by extra join conditions or removed duplicates.
1589  *
1590  * "pathkeys" is a List of PathKey nodes (see above), describing the sort
1591  * ordering of the path's output rows.
1592  *
1593  * We do not support copying Path trees, mainly because the circular linkages
1594  * between RelOptInfo and Path nodes can't be handled easily in a simple
1595  * depth-first traversal. We also don't have read support at the moment.
1596  */
1597 typedef struct Path
1598 {
1599  pg_node_attr(no_copy_equal, no_read)
1600 
1601  NodeTag type;
1602 
1603  /* tag identifying scan/join method */
1605 
1606  /*
1607  * the relation this path can build
1608  *
1609  * We do NOT print the parent, else we'd be in infinite recursion. We can
1610  * print the parent's relids for identification purposes, though.
1611  */
1612  RelOptInfo *parent pg_node_attr(write_only_relids);
1613 
1614  /*
1615  * list of Vars/Exprs, cost, width
1616  *
1617  * We print the pathtarget only if it's not the default one for the rel.
1618  */
1619  PathTarget *pathtarget pg_node_attr(write_only_nondefault_pathtarget);
1620 
1621  /*
1622  * parameterization info, or NULL if none
1623  *
1624  * We do not print the whole of param_info, since it's printed via
1625  * RelOptInfo; it's sufficient and less cluttering to print just the
1626  * required outer relids.
1627  */
1628  ParamPathInfo *param_info pg_node_attr(write_only_req_outer);
1629 
1630  /* engage parallel-aware logic? */
1632  /* OK to use as part of parallel plan? */
1634  /* desired # of workers; 0 = not parallel */
1636 
1637  /* estimated size/costs for path (see costsize.c for more info) */
1638  Cardinality rows; /* estimated number of result tuples */
1639  Cost startup_cost; /* cost expended before fetching any tuples */
1640  Cost total_cost; /* total cost (assuming all tuples fetched) */
1641 
1642  /* sort ordering of path's output; a List of PathKey nodes; see above */
1645 
1646 /* Macro for extracting a path's parameterization relids; beware double eval */
1647 #define PATH_REQ_OUTER(path) \
1648  ((path)->param_info ? (path)->param_info->ppi_req_outer : (Relids) NULL)
1649 
1650 /*----------
1651  * IndexPath represents an index scan over a single index.
1652  *
1653  * This struct is used for both regular indexscans and index-only scans;
1654  * path.pathtype is T_IndexScan or T_IndexOnlyScan to show which is meant.
1655  *
1656  * 'indexinfo' is the index to be scanned.
1657  *
1658  * 'indexclauses' is a list of IndexClause nodes, each representing one
1659  * index-checkable restriction, with implicit AND semantics across the list.
1660  * An empty list implies a full index scan.
1661  *
1662  * 'indexorderbys', if not NIL, is a list of ORDER BY expressions that have
1663  * been found to be usable as ordering operators for an amcanorderbyop index.
1664  * The list must match the path's pathkeys, ie, one expression per pathkey
1665  * in the same order. These are not RestrictInfos, just bare expressions,
1666  * since they generally won't yield booleans. It's guaranteed that each
1667  * expression has the index key on the left side of the operator.
1668  *
1669  * 'indexorderbycols' is an integer list of index column numbers (zero-based)
1670  * of the same length as 'indexorderbys', showing which index column each
1671  * ORDER BY expression is meant to be used with. (There is no restriction
1672  * on which index column each ORDER BY can be used with.)
1673  *
1674  * 'indexscandir' is one of:
1675  * ForwardScanDirection: forward scan of an index
1676  * BackwardScanDirection: backward scan of an ordered index
1677  * Unordered indexes will always have an indexscandir of ForwardScanDirection.
1678  *
1679  * 'indextotalcost' and 'indexselectivity' are saved in the IndexPath so that
1680  * we need not recompute them when considering using the same index in a
1681  * bitmap index/heap scan (see BitmapHeapPath). The costs of the IndexPath
1682  * itself represent the costs of an IndexScan or IndexOnlyScan plan type.
1683  *----------
1684  */
1685 typedef struct IndexPath
1686 {
1696 
1697 /*
1698  * Each IndexClause references a RestrictInfo node from the query's WHERE
1699  * or JOIN conditions, and shows how that restriction can be applied to
1700  * the particular index. We support both indexclauses that are directly
1701  * usable by the index machinery, which are typically of the form
1702  * "indexcol OP pseudoconstant", and those from which an indexable qual
1703  * can be derived. The simplest such transformation is that a clause
1704  * of the form "pseudoconstant OP indexcol" can be commuted to produce an
1705  * indexable qual (the index machinery expects the indexcol to be on the
1706  * left always). Another example is that we might be able to extract an
1707  * indexable range condition from a LIKE condition, as in "x LIKE 'foo%bar'"
1708  * giving rise to "x >= 'foo' AND x < 'fop'". Derivation of such lossy
1709  * conditions is done by a planner support function attached to the
1710  * indexclause's top-level function or operator.
1711  *
1712  * indexquals is a list of RestrictInfos for the directly-usable index
1713  * conditions associated with this IndexClause. In the simplest case
1714  * it's a one-element list whose member is iclause->rinfo. Otherwise,
1715  * it contains one or more directly-usable indexqual conditions extracted
1716  * from the given clause. The 'lossy' flag indicates whether the
1717  * indexquals are semantically equivalent to the original clause, or
1718  * represent a weaker condition.
1719  *
1720  * Normally, indexcol is the index of the single index column the clause
1721  * works on, and indexcols is NIL. But if the clause is a RowCompareExpr,
1722  * indexcol is the index of the leading column, and indexcols is a list of
1723  * all the affected columns. (Note that indexcols matches up with the
1724  * columns of the actual indexable RowCompareExpr in indexquals, which
1725  * might be different from the original in rinfo.)
1726  *
1727  * An IndexPath's IndexClause list is required to be ordered by index
1728  * column, i.e. the indexcol values must form a nondecreasing sequence.
1729  * (The order of multiple clauses for the same index column is unspecified.)
1730  */
1731 typedef struct IndexClause
1732 {
1733  pg_node_attr(no_copy_equal, no_read)
1734 
1735  NodeTag type;
1736  struct RestrictInfo *rinfo; /* original restriction or join clause */
1737  List *indexquals; /* indexqual(s) derived from it */
1738  bool lossy; /* are indexquals a lossy version of clause? */
1739  AttrNumber indexcol; /* index column the clause uses (zero-based) */
1740  List *indexcols; /* multiple index columns, if RowCompare */
1742 
1743 /*
1744  * BitmapHeapPath represents one or more indexscans that generate TID bitmaps
1745  * instead of directly accessing the heap, followed by AND/OR combinations
1746  * to produce a single bitmap, followed by a heap scan that uses the bitmap.
1747  * Note that the output is always considered unordered, since it will come
1748  * out in physical heap order no matter what the underlying indexes did.
1749  *
1750  * The individual indexscans are represented by IndexPath nodes, and any
1751  * logic on top of them is represented by a tree of BitmapAndPath and
1752  * BitmapOrPath nodes. Notice that we can use the same IndexPath node both
1753  * to represent a regular (or index-only) index scan plan, and as the child
1754  * of a BitmapHeapPath that represents scanning the same index using a
1755  * BitmapIndexScan. The startup_cost and total_cost figures of an IndexPath
1756  * always represent the costs to use it as a regular (or index-only)
1757  * IndexScan. The costs of a BitmapIndexScan can be computed using the
1758  * IndexPath's indextotalcost and indexselectivity.
1759  */
1760 typedef struct BitmapHeapPath
1761 {
1763  Path *bitmapqual; /* IndexPath, BitmapAndPath, BitmapOrPath */
1765 
1766 /*
1767  * BitmapAndPath represents a BitmapAnd plan node; it can only appear as
1768  * part of the substructure of a BitmapHeapPath. The Path structure is
1769  * a bit more heavyweight than we really need for this, but for simplicity
1770  * we make it a derivative of Path anyway.
1771  */
1772 typedef struct BitmapAndPath
1773 {
1775  List *bitmapquals; /* IndexPaths and BitmapOrPaths */
1778 
1779 /*
1780  * BitmapOrPath represents a BitmapOr plan node; it can only appear as
1781  * part of the substructure of a BitmapHeapPath. The Path structure is
1782  * a bit more heavyweight than we really need for this, but for simplicity
1783  * we make it a derivative of Path anyway.
1784  */
1785 typedef struct BitmapOrPath
1786 {
1788  List *bitmapquals; /* IndexPaths and BitmapAndPaths */
1791 
1792 /*
1793  * TidPath represents a scan by TID
1794  *
1795  * tidquals is an implicitly OR'ed list of qual expressions of the form
1796  * "CTID = pseudoconstant", or "CTID = ANY(pseudoconstant_array)",
1797  * or a CurrentOfExpr for the relation.
1798  */
1799 typedef struct TidPath
1800 {
1802  List *tidquals; /* qual(s) involving CTID = something */
1804 
1805 /*
1806  * TidRangePath represents a scan by a contiguous range of TIDs
1807  *
1808  * tidrangequals is an implicitly AND'ed list of qual expressions of the form
1809  * "CTID relop pseudoconstant", where relop is one of >,>=,<,<=.
1810  */
1811 typedef struct TidRangePath
1812 {
1816 
1817 /*
1818  * SubqueryScanPath represents a scan of an unflattened subquery-in-FROM
1819  *
1820  * Note that the subpath comes from a different planning domain; for example
1821  * RTE indexes within it mean something different from those known to the
1822  * SubqueryScanPath. path.parent->subroot is the planning context needed to
1823  * interpret the subpath.
1824  */
1825 typedef struct SubqueryScanPath
1826 {
1828  Path *subpath; /* path representing subquery execution */
1830 
1831 /*
1832  * ForeignPath represents a potential scan of a foreign table, foreign join
1833  * or foreign upper-relation.
1834  *
1835  * fdw_private stores FDW private data about the scan. While fdw_private is
1836  * not actually touched by the core code during normal operations, it's
1837  * generally a good idea to use a representation that can be dumped by
1838  * nodeToString(), so that you can examine the structure during debugging
1839  * with tools like pprint().
1840  */
1841 typedef struct ForeignPath
1842 {
1847 
1848 /*
1849  * CustomPath represents a table scan done by some out-of-core extension.
1850  *
1851  * We provide a set of hooks here - which the provider must take care to set
1852  * up correctly - to allow extensions to supply their own methods of scanning
1853  * a relation. For example, a provider might provide GPU acceleration, a
1854  * cache-based scan, or some other kind of logic we haven't dreamed up yet.
1855  *
1856  * CustomPaths can be injected into the planning process for a relation by
1857  * set_rel_pathlist_hook functions.
1858  *
1859  * Core code must avoid assuming that the CustomPath is only as large as
1860  * the structure declared here; providers are allowed to make it the first
1861  * element in a larger structure. (Since the planner never copies Paths,
1862  * this doesn't add any complication.) However, for consistency with the
1863  * FDW case, we provide a "custom_private" field in CustomPath; providers
1864  * may prefer to use that rather than define another struct type.
1865  */
1866 
1867 struct CustomPathMethods;
1868 
1869 typedef struct CustomPath
1870 {
1872  uint32 flags; /* mask of CUSTOMPATH_* flags, see
1873  * nodes/extensible.h */
1874  List *custom_paths; /* list of child Path nodes, if any */
1878 
1879 /*
1880  * AppendPath represents an Append plan, ie, successive execution of
1881  * several member plans.
1882  *
1883  * For partial Append, 'subpaths' contains non-partial subpaths followed by
1884  * partial subpaths.
1885  *
1886  * Note: it is possible for "subpaths" to contain only one, or even no,
1887  * elements. These cases are optimized during create_append_plan.
1888  * In particular, an AppendPath with no subpaths is a "dummy" path that
1889  * is created to represent the case that a relation is provably empty.
1890  * (This is a convenient representation because it means that when we build
1891  * an appendrel and find that all its children have been excluded, no extra
1892  * action is needed to recognize the relation as dummy.)
1893  */
1894 typedef struct AppendPath
1895 {
1897  List *subpaths; /* list of component Paths */
1898  /* Index of first partial path in subpaths; list_length(subpaths) if none */
1900  Cardinality limit_tuples; /* hard limit on output tuples, or -1 */
1902 
1903 #define IS_DUMMY_APPEND(p) \
1904  (IsA((p), AppendPath) && ((AppendPath *) (p))->subpaths == NIL)
1905 
1906 /*
1907  * A relation that's been proven empty will have one path that is dummy
1908  * (but might have projection paths on top). For historical reasons,
1909  * this is provided as a macro that wraps is_dummy_rel().
1910  */
1911 #define IS_DUMMY_REL(r) is_dummy_rel(r)
1912 extern bool is_dummy_rel(RelOptInfo *rel);
1913 
1914 /*
1915  * MergeAppendPath represents a MergeAppend plan, ie, the merging of sorted
1916  * results from several member plans to produce similarly-sorted output.
1917  */
1918 typedef struct MergeAppendPath
1919 {
1921  List *subpaths; /* list of component Paths */
1922  Cardinality limit_tuples; /* hard limit on output tuples, or -1 */
1924 
1925 /*
1926  * GroupResultPath represents use of a Result plan node to compute the
1927  * output of a degenerate GROUP BY case, wherein we know we should produce
1928  * exactly one row, which might then be filtered by a HAVING qual.
1929  *
1930  * Note that quals is a list of bare clauses, not RestrictInfos.
1931  */
1932 typedef struct GroupResultPath
1933 {
1937 
1938 /*
1939  * MaterialPath represents use of a Material plan node, i.e., caching of
1940  * the output of its subpath. This is used when the subpath is expensive
1941  * and needs to be scanned repeatedly, or when we need mark/restore ability
1942  * and the subpath doesn't have it.
1943  */
1944 typedef struct MaterialPath
1945 {
1949 
1950 /*
1951  * MemoizePath represents a Memoize plan node, i.e., a cache that caches
1952  * tuples from parameterized paths to save the underlying node from having to
1953  * be rescanned for parameter values which are already cached.
1954  */
1955 typedef struct MemoizePath
1956 {
1958  Path *subpath; /* outerpath to cache tuples from */
1959  List *hash_operators; /* OIDs of hash equality ops for cache keys */
1960  List *param_exprs; /* expressions that are cache keys */
1961  bool singlerow; /* true if the cache entry is to be marked as
1962  * complete after caching the first record. */
1963  bool binary_mode; /* true when cache key should be compared bit
1964  * by bit, false when using hash equality ops */
1965  Cardinality calls; /* expected number of rescans */
1966  uint32 est_entries; /* The maximum number of entries that the
1967  * planner expects will fit in the cache, or 0
1968  * if unknown */
1970 
1971 /*
1972  * UniquePath represents elimination of distinct rows from the output of
1973  * its subpath.
1974  *
1975  * This can represent significantly different plans: either hash-based or
1976  * sort-based implementation, or a no-op if the input path can be proven
1977  * distinct already. The decision is sufficiently localized that it's not
1978  * worth having separate Path node types. (Note: in the no-op case, we could
1979  * eliminate the UniquePath node entirely and just return the subpath; but
1980  * it's convenient to have a UniquePath in the path tree to signal upper-level
1981  * routines that the input is known distinct.)
1982  */
1983 typedef enum UniquePathMethod
1984 {
1985  UNIQUE_PATH_NOOP, /* input is known unique already */
1986  UNIQUE_PATH_HASH, /* use hashing */
1987  UNIQUE_PATH_SORT /* use sorting */
1989 
1990 typedef struct UniquePath
1991 {
1995  List *in_operators; /* equality operators of the IN clause */
1996  List *uniq_exprs; /* expressions to be made unique */
1998 
1999 /*
2000  * GatherPath runs several copies of a plan in parallel and collects the
2001  * results. The parallel leader may also execute the plan, unless the
2002  * single_copy flag is set.
2003  */
2004 typedef struct GatherPath
2005 {
2007  Path *subpath; /* path for each worker */
2008  bool single_copy; /* don't execute path more than once */
2009  int num_workers; /* number of workers sought to help */
2011 
2012 /*
2013  * GatherMergePath runs several copies of a plan in parallel and collects
2014  * the results, preserving their common sort order.
2015  */
2016 typedef struct GatherMergePath
2017 {
2019  Path *subpath; /* path for each worker */
2020  int num_workers; /* number of workers sought to help */
2022 
2023 
2024 /*
2025  * All join-type paths share these fields.
2026  */
2027 
2028 typedef struct JoinPath
2029 {
2030  pg_node_attr(abstract)
2031 
2032  Path path;
2033 
2035 
2036  bool inner_unique; /* each outer tuple provably matches no more
2037  * than one inner tuple */
2038 
2039  Path *outerjoinpath; /* path for the outer side of the join */
2040  Path *innerjoinpath; /* path for the inner side of the join */
2041 
2042  List *joinrestrictinfo; /* RestrictInfos to apply to join */
2043 
2044  /*
2045  * See the notes for RelOptInfo and ParamPathInfo to understand why
2046  * joinrestrictinfo is needed in JoinPath, and can't be merged into the
2047  * parent RelOptInfo.
2048  */
2050 
2051 /*
2052  * A nested-loop path needs no special fields.
2053  */
2054 
2055 typedef struct NestPath
2056 {
2059 
2060 /*
2061  * A mergejoin path has these fields.
2062  *
2063  * Unlike other path types, a MergePath node doesn't represent just a single
2064  * run-time plan node: it can represent up to four. Aside from the MergeJoin
2065  * node itself, there can be a Sort node for the outer input, a Sort node
2066  * for the inner input, and/or a Material node for the inner input. We could
2067  * represent these nodes by separate path nodes, but considering how many
2068  * different merge paths are investigated during a complex join problem,
2069  * it seems better to avoid unnecessary palloc overhead.
2070  *
2071  * path_mergeclauses lists the clauses (in the form of RestrictInfos)
2072  * that will be used in the merge.
2073  *
2074  * Note that the mergeclauses are a subset of the parent relation's
2075  * restriction-clause list. Any join clauses that are not mergejoinable
2076  * appear only in the parent's restrict list, and must be checked by a
2077  * qpqual at execution time.
2078  *
2079  * outersortkeys (resp. innersortkeys) is NIL if the outer path
2080  * (resp. inner path) is already ordered appropriately for the
2081  * mergejoin. If it is not NIL then it is a PathKeys list describing
2082  * the ordering that must be created by an explicit Sort node.
2083  *
2084  * skip_mark_restore is true if the executor need not do mark/restore calls.
2085  * Mark/restore overhead is usually required, but can be skipped if we know
2086  * that the executor need find only one match per outer tuple, and that the
2087  * mergeclauses are sufficient to identify a match. In such cases the
2088  * executor can immediately advance the outer relation after processing a
2089  * match, and therefore it need never back up the inner relation.
2090  *
2091  * materialize_inner is true if a Material node should be placed atop the
2092  * inner input. This may appear with or without an inner Sort step.
2093  */
2094 
2095 typedef struct MergePath
2096 {
2098  List *path_mergeclauses; /* join clauses to be used for merge */
2099  List *outersortkeys; /* keys for explicit sort, if any */
2100  List *innersortkeys; /* keys for explicit sort, if any */
2101  bool skip_mark_restore; /* can executor skip mark/restore? */
2102  bool materialize_inner; /* add Materialize to inner? */
2104 
2105 /*
2106  * A hashjoin path has these fields.
2107  *
2108  * The remarks above for mergeclauses apply for hashclauses as well.
2109  *
2110  * Hashjoin does not care what order its inputs appear in, so we have
2111  * no need for sortkeys.
2112  */
2113 
2114 typedef struct HashPath
2115 {
2117  List *path_hashclauses; /* join clauses used for hashing */
2118  int num_batches; /* number of batches expected */
2119  Cardinality inner_rows_total; /* total inner rows expected */
2121 
2122 /*
2123  * ProjectionPath represents a projection (that is, targetlist computation)
2124  *
2125  * Nominally, this path node represents using a Result plan node to do a
2126  * projection step. However, if the input plan node supports projection,
2127  * we can just modify its output targetlist to do the required calculations
2128  * directly, and not need a Result. In some places in the planner we can just
2129  * jam the desired PathTarget into the input path node (and adjust its cost
2130  * accordingly), so we don't need a ProjectionPath. But in other places
2131  * it's necessary to not modify the input path node, so we need a separate
2132  * ProjectionPath node, which is marked dummy to indicate that we intend to
2133  * assign the work to the input plan node. The estimated cost for the
2134  * ProjectionPath node will account for whether a Result will be used or not.
2135  */
2136 typedef struct ProjectionPath
2137 {
2139  Path *subpath; /* path representing input source */
2140  bool dummypp; /* true if no separate Result is needed */
2142 
2143 /*
2144  * ProjectSetPath represents evaluation of a targetlist that includes
2145  * set-returning function(s), which will need to be implemented by a
2146  * ProjectSet plan node.
2147  */
2148 typedef struct ProjectSetPath
2149 {
2151  Path *subpath; /* path representing input source */
2153 
2154 /*
2155  * SortPath represents an explicit sort step
2156  *
2157  * The sort keys are, by definition, the same as path.pathkeys.
2158  *
2159  * Note: the Sort plan node cannot project, so path.pathtarget must be the
2160  * same as the input's pathtarget.
2161  */
2162 typedef struct SortPath
2163 {
2165  Path *subpath; /* path representing input source */
2167 
2168 /*
2169  * IncrementalSortPath represents an incremental sort step
2170  *
2171  * This is like a regular sort, except some leading key columns are assumed
2172  * to be ordered already.
2173  */
2174 typedef struct IncrementalSortPath
2175 {
2177  int nPresortedCols; /* number of presorted columns */
2179 
2180 /*
2181  * GroupPath represents grouping (of presorted input)
2182  *
2183  * groupClause represents the columns to be grouped on; the input path
2184  * must be at least that well sorted.
2185  *
2186  * We can also apply a qual to the grouped rows (equivalent of HAVING)
2187  */
2188 typedef struct GroupPath
2189 {
2191  Path *subpath; /* path representing input source */
2192  List *groupClause; /* a list of SortGroupClause's */
2193  List *qual; /* quals (HAVING quals), if any */
2195 
2196 /*
2197  * UpperUniquePath represents adjacent-duplicate removal (in presorted input)
2198  *
2199  * The columns to be compared are the first numkeys columns of the path's
2200  * pathkeys. The input is presumed already sorted that way.
2201  */
2202 typedef struct UpperUniquePath
2203 {
2205  Path *subpath; /* path representing input source */
2206  int numkeys; /* number of pathkey columns to compare */
2208 
2209 /*
2210  * AggPath represents generic computation of aggregate functions
2211  *
2212  * This may involve plain grouping (but not grouping sets), using either
2213  * sorted or hashed grouping; for the AGG_SORTED case, the input must be
2214  * appropriately presorted.
2215  */
2216 typedef struct AggPath
2217 {
2219  Path *subpath; /* path representing input source */
2220  AggStrategy aggstrategy; /* basic strategy, see nodes.h */
2221  AggSplit aggsplit; /* agg-splitting mode, see nodes.h */
2222  Cardinality numGroups; /* estimated number of groups in input */
2223  uint64 transitionSpace; /* for pass-by-ref transition data */
2224  List *groupClause; /* a list of SortGroupClause's */
2225  List *qual; /* quals (HAVING quals), if any */
2227 
2228 /*
2229  * Various annotations used for grouping sets in the planner.
2230  */
2231 
2232 typedef struct GroupingSetData
2233 {
2234  pg_node_attr(no_copy_equal, no_read)
2235 
2236  NodeTag type;
2237  List *set; /* grouping set as list of sortgrouprefs */
2238  Cardinality numGroups; /* est. number of result groups */
2240 
2241 typedef struct RollupData
2242 {
2243  pg_node_attr(no_copy_equal, no_read)
2244 
2245  NodeTag type;
2246  List *groupClause; /* applicable subset of parse->groupClause */
2247  List *gsets; /* lists of integer indexes into groupClause */
2248  List *gsets_data; /* list of GroupingSetData */
2249  Cardinality numGroups; /* est. number of result groups */
2250  bool hashable; /* can be hashed */
2251  bool is_hashed; /* to be implemented as a hashagg */
2253 
2254 /*
2255  * GroupingSetsPath represents a GROUPING SETS aggregation
2256  */
2257 
2258 typedef struct GroupingSetsPath
2259 {
2261  Path *subpath; /* path representing input source */
2262  AggStrategy aggstrategy; /* basic strategy */
2263  List *rollups; /* list of RollupData */
2264  List *qual; /* quals (HAVING quals), if any */
2265  uint64 transitionSpace; /* for pass-by-ref transition data */
2267 
2268 /*
2269  * MinMaxAggPath represents computation of MIN/MAX aggregates from indexes
2270  */
2271 typedef struct MinMaxAggPath
2272 {
2274  List *mmaggregates; /* list of MinMaxAggInfo */
2275  List *quals; /* HAVING quals, if any */
2277 
2278 /*
2279  * WindowAggPath represents generic computation of window functions
2280  */
2281 typedef struct WindowAggPath
2282 {
2284  Path *subpath; /* path representing input source */
2285  WindowClause *winclause; /* WindowClause we'll be using */
2286  List *qual; /* lower-level WindowAgg runconditions */
2287  bool topwindow; /* false for all apart from the WindowAgg
2288  * that's closest to the root of the plan */
2290 
2291 /*
2292  * SetOpPath represents a set-operation, that is INTERSECT or EXCEPT
2293  */
2294 typedef struct SetOpPath
2295 {
2297  Path *subpath; /* path representing input source */
2298  SetOpCmd cmd; /* what to do, see nodes.h */
2299  SetOpStrategy strategy; /* how to do it, see nodes.h */
2300  List *distinctList; /* SortGroupClauses identifying target cols */
2301  AttrNumber flagColIdx; /* where is the flag column, if any */
2302  int firstFlag; /* flag value for first input relation */
2303  Cardinality numGroups; /* estimated number of groups in input */
2305 
2306 /*
2307  * RecursiveUnionPath represents a recursive UNION node
2308  */
2309 typedef struct RecursiveUnionPath
2310 {
2312  Path *leftpath; /* paths representing input sources */
2314  List *distinctList; /* SortGroupClauses identifying target cols */
2315  int wtParam; /* ID of Param representing work table */
2316  Cardinality numGroups; /* estimated number of groups in input */
2318 
2319 /*
2320  * LockRowsPath represents acquiring row locks for SELECT FOR UPDATE/SHARE
2321  */
2322 typedef struct LockRowsPath
2323 {
2325  Path *subpath; /* path representing input source */
2326  List *rowMarks; /* a list of PlanRowMark's */
2327  int epqParam; /* ID of Param for EvalPlanQual re-eval */
2329 
2330 /*
2331  * ModifyTablePath represents performing INSERT/UPDATE/DELETE/MERGE
2332  *
2333  * We represent most things that will be in the ModifyTable plan node
2334  * literally, except we have a child Path not Plan. But analysis of the
2335  * OnConflictExpr is deferred to createplan.c, as is collection of FDW data.
2336  */
2337 typedef struct ModifyTablePath
2338 {
2340  Path *subpath; /* Path producing source data */
2341  CmdType operation; /* INSERT, UPDATE, DELETE, or MERGE */
2342  bool canSetTag; /* do we set the command tag/es_processed? */
2343  Index nominalRelation; /* Parent RT index for use of EXPLAIN */
2344  Index rootRelation; /* Root RT index, if target is partitioned */
2345  bool partColsUpdated; /* some part key in hierarchy updated? */
2346  List *resultRelations; /* integer list of RT indexes */
2347  List *updateColnosLists; /* per-target-table update_colnos lists */
2348  List *withCheckOptionLists; /* per-target-table WCO lists */
2349  List *returningLists; /* per-target-table RETURNING tlists */
2350  List *rowMarks; /* PlanRowMarks (non-locking only) */
2351  OnConflictExpr *onconflict; /* ON CONFLICT clause, or NULL */
2352  int epqParam; /* ID of Param for EvalPlanQual re-eval */
2353  List *mergeActionLists; /* per-target-table lists of actions for
2354  * MERGE */
2356 
2357 /*
2358  * LimitPath represents applying LIMIT/OFFSET restrictions
2359  */
2360 typedef struct LimitPath
2361 {
2363  Path *subpath; /* path representing input source */
2364  Node *limitOffset; /* OFFSET parameter, or NULL if none */
2365  Node *limitCount; /* COUNT parameter, or NULL if none */
2366  LimitOption limitOption; /* FETCH FIRST with ties or exact number */
2368 
2369 
2370 /*
2371  * Restriction clause info.
2372  *
2373  * We create one of these for each AND sub-clause of a restriction condition
2374  * (WHERE or JOIN/ON clause). Since the restriction clauses are logically
2375  * ANDed, we can use any one of them or any subset of them to filter out
2376  * tuples, without having to evaluate the rest. The RestrictInfo node itself
2377  * stores data used by the optimizer while choosing the best query plan.
2378  *
2379  * If a restriction clause references a single base relation, it will appear
2380  * in the baserestrictinfo list of the RelOptInfo for that base rel.
2381  *
2382  * If a restriction clause references more than one base+OJ relation, it will
2383  * appear in the joininfo list of every RelOptInfo that describes a strict
2384  * subset of the relations mentioned in the clause. The joininfo lists are
2385  * used to drive join tree building by selecting plausible join candidates.
2386  * The clause cannot actually be applied until we have built a join rel
2387  * containing all the relations it references, however.
2388  *
2389  * When we construct a join rel that includes all the relations referenced
2390  * in a multi-relation restriction clause, we place that clause into the
2391  * joinrestrictinfo lists of paths for the join rel, if neither left nor
2392  * right sub-path includes all relations referenced in the clause. The clause
2393  * will be applied at that join level, and will not propagate any further up
2394  * the join tree. (Note: the "predicate migration" code was once intended to
2395  * push restriction clauses up and down the plan tree based on evaluation
2396  * costs, but it's dead code and is unlikely to be resurrected in the
2397  * foreseeable future.)
2398  *
2399  * Note that in the presence of more than two rels, a multi-rel restriction
2400  * might reach different heights in the join tree depending on the join
2401  * sequence we use. So, these clauses cannot be associated directly with
2402  * the join RelOptInfo, but must be kept track of on a per-join-path basis.
2403  *
2404  * RestrictInfos that represent equivalence conditions (i.e., mergejoinable
2405  * equalities that are not outerjoin-delayed) are handled a bit differently.
2406  * Initially we attach them to the EquivalenceClasses that are derived from
2407  * them. When we construct a scan or join path, we look through all the
2408  * EquivalenceClasses and generate derived RestrictInfos representing the
2409  * minimal set of conditions that need to be checked for this particular scan
2410  * or join to enforce that all members of each EquivalenceClass are in fact
2411  * equal in all rows emitted by the scan or join.
2412  *
2413  * The clause_relids field lists the base plus outer-join RT indexes that
2414  * actually appear in the clause. required_relids lists the minimum set of
2415  * relids needed to evaluate the clause; while this is often equal to
2416  * clause_relids, it can be more. We will add relids to required_relids when
2417  * we need to force an outer join ON clause to be evaluated exactly at the
2418  * level of the outer join, which is true except when it is a "degenerate"
2419  * condition that references only Vars from the nullable side of the join.
2420  *
2421  * RestrictInfo nodes contain a flag to indicate whether a qual has been
2422  * pushed down to a lower level than its original syntactic placement in the
2423  * join tree would suggest. If an outer join prevents us from pushing a qual
2424  * down to its "natural" semantic level (the level associated with just the
2425  * base rels used in the qual) then we mark the qual with a "required_relids"
2426  * value including more than just the base rels it actually uses. By
2427  * pretending that the qual references all the rels required to form the outer
2428  * join, we prevent it from being evaluated below the outer join's joinrel.
2429  * When we do form the outer join's joinrel, we still need to distinguish
2430  * those quals that are actually in that join's JOIN/ON condition from those
2431  * that appeared elsewhere in the tree and were pushed down to the join rel
2432  * because they used no other rels. That's what the is_pushed_down flag is
2433  * for; it tells us that a qual is not an OUTER JOIN qual for the set of base
2434  * rels listed in required_relids. A clause that originally came from WHERE
2435  * or an INNER JOIN condition will *always* have its is_pushed_down flag set.
2436  * It's possible for an OUTER JOIN clause to be marked is_pushed_down too,
2437  * if we decide that it can be pushed down into the nullable side of the join.
2438  * In that case it acts as a plain filter qual for wherever it gets evaluated.
2439  * (In short, is_pushed_down is only false for non-degenerate outer join
2440  * conditions. Possibly we should rename it to reflect that meaning? But
2441  * see also the comments for RINFO_IS_PUSHED_DOWN, below.)
2442  *
2443  * There is also an outer_relids field, which is NULL except for outer join
2444  * clauses; for those, it is the set of relids on the outer side of the
2445  * clause's outer join. (These are rels that the clause cannot be applied to
2446  * in parameterized scans, since pushing it into the join's outer side would
2447  * lead to wrong answers.)
2448  *
2449  * To handle security-barrier conditions efficiently, we mark RestrictInfo
2450  * nodes with a security_level field, in which higher values identify clauses
2451  * coming from less-trusted sources. The exact semantics are that a clause
2452  * cannot be evaluated before another clause with a lower security_level value
2453  * unless the first clause is leakproof. As with outer-join clauses, this
2454  * creates a reason for clauses to sometimes need to be evaluated higher in
2455  * the join tree than their contents would suggest; and even at a single plan
2456  * node, this rule constrains the order of application of clauses.
2457  *
2458  * In general, the referenced clause might be arbitrarily complex. The
2459  * kinds of clauses we can handle as indexscan quals, mergejoin clauses,
2460  * or hashjoin clauses are limited (e.g., no volatile functions). The code
2461  * for each kind of path is responsible for identifying the restrict clauses
2462  * it can use and ignoring the rest. Clauses not implemented by an indexscan,
2463  * mergejoin, or hashjoin will be placed in the plan qual or joinqual field
2464  * of the finished Plan node, where they will be enforced by general-purpose
2465  * qual-expression-evaluation code. (But we are still entitled to count
2466  * their selectivity when estimating the result tuple count, if we
2467  * can guess what it is...)
2468  *
2469  * When the referenced clause is an OR clause, we generate a modified copy
2470  * in which additional RestrictInfo nodes are inserted below the top-level
2471  * OR/AND structure. This is a convenience for OR indexscan processing:
2472  * indexquals taken from either the top level or an OR subclause will have
2473  * associated RestrictInfo nodes.
2474  *
2475  * The can_join flag is set true if the clause looks potentially useful as
2476  * a merge or hash join clause, that is if it is a binary opclause with
2477  * nonoverlapping sets of relids referenced in the left and right sides.
2478  * (Whether the operator is actually merge or hash joinable isn't checked,
2479  * however.)
2480  *
2481  * The pseudoconstant flag is set true if the clause contains no Vars of
2482  * the current query level and no volatile functions. Such a clause can be
2483  * pulled out and used as a one-time qual in a gating Result node. We keep
2484  * pseudoconstant clauses in the same lists as other RestrictInfos so that
2485  * the regular clause-pushing machinery can assign them to the correct join
2486  * level, but they need to be treated specially for cost and selectivity
2487  * estimates. Note that a pseudoconstant clause can never be an indexqual
2488  * or merge or hash join clause, so it's of no interest to large parts of
2489  * the planner.
2490  *
2491  * When we generate multiple versions of a clause so as to have versions
2492  * that will work after commuting some left joins per outer join identity 3,
2493  * we mark the one with the fewest nullingrels bits with has_clone = true,
2494  * and the rest with is_clone = true. This allows proper filtering of
2495  * these redundant clauses, so that we apply only one version of them.
2496  *
2497  * When join clauses are generated from EquivalenceClasses, there may be
2498  * several equally valid ways to enforce join equivalence, of which we need
2499  * apply only one. We mark clauses of this kind by setting parent_ec to
2500  * point to the generating EquivalenceClass. Multiple clauses with the same
2501  * parent_ec in the same join are redundant.
2502  *
2503  * Most fields are ignored for equality, since they may not be set yet, and
2504  * should be derivable from the clause anyway.
2505  *
2506  * parent_ec, left_ec, right_ec are not printed, lest it lead to infinite
2507  * recursion in plan tree dump.
2508  */
2509 
2510 typedef struct RestrictInfo
2511 {
2512  pg_node_attr(no_read)
2513 
2514  NodeTag type;
2515 
2516  /* the represented clause of WHERE or JOIN */
2518 
2519  /* true if clause was pushed down in level */
2521 
2522  /* see comment above */
2523  bool can_join pg_node_attr(equal_ignore);
2524 
2525  /* see comment above */
2526  bool pseudoconstant pg_node_attr(equal_ignore);
2527 
2528  /* see comment above */
2530  bool is_clone;
2531 
2532  /* true if known to contain no leaked Vars */
2533  bool leakproof pg_node_attr(equal_ignore);
2534 
2535  /* indicates if clause contains any volatile functions */
2536  VolatileFunctionStatus has_volatile pg_node_attr(equal_ignore);
2537 
2538  /* see comment above */
2540 
2541  /* number of base rels in clause_relids */
2542  int num_base_rels pg_node_attr(equal_ignore);
2543 
2544  /* The relids (varnos+varnullingrels) actually referenced in the clause: */
2545  Relids clause_relids pg_node_attr(equal_ignore);
2546 
2547  /* The set of relids required to evaluate the clause: */
2549 
2550  /* If an outer-join clause, the outer-side relations, else NULL: */
2552 
2553  /*
2554  * Relids in the left/right side of the clause. These fields are set for
2555  * any binary opclause.
2556  */
2557  Relids left_relids pg_node_attr(equal_ignore);
2558  Relids right_relids pg_node_attr(equal_ignore);
2559 
2560  /*
2561  * Modified clause with RestrictInfos. This field is NULL unless clause
2562  * is an OR clause.
2563  */
2564  Expr *orclause pg_node_attr(equal_ignore);
2565 
2566  /*----------
2567  * Serial number of this RestrictInfo. This is unique within the current
2568  * PlannerInfo context, with a few critical exceptions:
2569  * 1. When we generate multiple clones of the same qual condition to
2570  * cope with outer join identity 3, all the clones get the same serial
2571  * number. This reflects that we only want to apply one of them in any
2572  * given plan.
2573  * 2. If we manufacture a commuted version of a qual to use as an index
2574  * condition, it copies the original's rinfo_serial, since it is in
2575  * practice the same condition.
2576  * 3. RestrictInfos made for a child relation copy their parent's
2577  * rinfo_serial. Likewise, when an EquivalenceClass makes a derived
2578  * equality clause for a child relation, it copies the rinfo_serial of
2579  * the matching equality clause for the parent. This allows detection
2580  * of redundant pushed-down equality clauses.
2581  *----------
2582  */
2584 
2585  /*
2586  * Generating EquivalenceClass. This field is NULL unless clause is
2587  * potentially redundant.
2588  */
2589  EquivalenceClass *parent_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
2590 
2591  /*
2592  * cache space for cost and selectivity
2593  */
2594 
2595  /* eval cost of clause; -1 if not yet set */
2596  QualCost eval_cost pg_node_attr(equal_ignore);
2597 
2598  /* selectivity for "normal" (JOIN_INNER) semantics; -1 if not yet set */
2599  Selectivity norm_selec pg_node_attr(equal_ignore);
2600  /* selectivity for outer join semantics; -1 if not yet set */
2601  Selectivity outer_selec pg_node_attr(equal_ignore);
2602 
2603  /*
2604  * opfamilies containing clause operator; valid if clause is
2605  * mergejoinable, else NIL
2606  */
2607  List *mergeopfamilies pg_node_attr(equal_ignore);
2608 
2609  /*
2610  * cache space for mergeclause processing; NULL if not yet set
2611  */
2612 
2613  /* EquivalenceClass containing lefthand */
2614  EquivalenceClass *left_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
2615  /* EquivalenceClass containing righthand */
2616  EquivalenceClass *right_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
2617  /* EquivalenceMember for lefthand */
2618  EquivalenceMember *left_em pg_node_attr(copy_as_scalar, equal_ignore);
2619  /* EquivalenceMember for righthand */
2620  EquivalenceMember *right_em pg_node_attr(copy_as_scalar, equal_ignore);
2621 
2622  /*
2623  * List of MergeScanSelCache structs. Those aren't Nodes, so hard to
2624  * copy; instead replace with NIL. That has the effect that copying will
2625  * just reset the cache. Likewise, can't compare or print them.
2626  */
2627  List *scansel_cache pg_node_attr(copy_as(NIL), equal_ignore, read_write_ignore);
2628 
2629  /*
2630  * transient workspace for use while considering a specific join path; T =
2631  * outer var on left, F = on right
2632  */
2633  bool outer_is_left pg_node_attr(equal_ignore);
2634 
2635  /*
2636  * copy of clause operator; valid if clause is hashjoinable, else
2637  * InvalidOid
2638  */
2639  Oid hashjoinoperator pg_node_attr(equal_ignore);
2640 
2641  /*
2642  * cache space for hashclause processing; -1 if not yet set
2643  */
2644  /* avg bucketsize of left side */
2645  Selectivity left_bucketsize pg_node_attr(equal_ignore);
2646  /* avg bucketsize of right side */
2647  Selectivity right_bucketsize pg_node_attr(equal_ignore);
2648  /* left side's most common val's freq */
2649  Selectivity left_mcvfreq pg_node_attr(equal_ignore);
2650  /* right side's most common val's freq */
2651  Selectivity right_mcvfreq pg_node_attr(equal_ignore);
2652 
2653  /* hash equality operators used for memoize nodes, else InvalidOid */
2654  Oid left_hasheqoperator pg_node_attr(equal_ignore);
2655  Oid right_hasheqoperator pg_node_attr(equal_ignore);
2657 
2658 /*
2659  * This macro embodies the correct way to test whether a RestrictInfo is
2660  * "pushed down" to a given outer join, that is, should be treated as a filter
2661  * clause rather than a join clause at that outer join. This is certainly so
2662  * if is_pushed_down is true; but examining that is not sufficient anymore,
2663  * because outer-join clauses will get pushed down to lower outer joins when
2664  * we generate a path for the lower outer join that is parameterized by the
2665  * LHS of the upper one. We can detect such a clause by noting that its
2666  * required_relids exceed the scope of the join.
2667  */
2668 #define RINFO_IS_PUSHED_DOWN(rinfo, joinrelids) \
2669  ((rinfo)->is_pushed_down || \
2670  !bms_is_subset((rinfo)->required_relids, joinrelids))
2671 
2672 /*
2673  * Since mergejoinscansel() is a relatively expensive function, and would
2674  * otherwise be invoked many times while planning a large join tree,
2675  * we go out of our way to cache its results. Each mergejoinable
2676  * RestrictInfo carries a list of the specific sort orderings that have
2677  * been considered for use with it, and the resulting selectivities.
2678  */
2679 typedef struct MergeScanSelCache
2680 {
2681  /* Ordering details (cache lookup key) */
2682  Oid opfamily; /* btree opfamily defining the ordering */
2683  Oid collation; /* collation for the ordering */
2684  int strategy; /* sort direction (ASC or DESC) */
2685  bool nulls_first; /* do NULLs come before normal values? */
2686  /* Results */
2687  Selectivity leftstartsel; /* first-join fraction for clause left side */
2688  Selectivity leftendsel; /* last-join fraction for clause left side */
2689  Selectivity rightstartsel; /* first-join fraction for clause right side */
2690  Selectivity rightendsel; /* last-join fraction for clause right side */
2692 
2693 /*
2694  * Placeholder node for an expression to be evaluated below the top level
2695  * of a plan tree. This is used during planning to represent the contained
2696  * expression. At the end of the planning process it is replaced by either
2697  * the contained expression or a Var referring to a lower-level evaluation of
2698  * the contained expression. Generally the evaluation occurs below an outer
2699  * join, and Var references above the outer join might thereby yield NULL
2700  * instead of the expression value.
2701  *
2702  * phrels and phlevelsup correspond to the varno/varlevelsup fields of a
2703  * plain Var, except that phrels has to be a relid set since the evaluation
2704  * level of a PlaceHolderVar might be a join rather than a base relation.
2705  * Likewise, phnullingrels corresponds to varnullingrels.
2706  *
2707  * Although the planner treats this as an expression node type, it is not
2708  * recognized by the parser or executor, so we declare it here rather than
2709  * in primnodes.h.
2710  *
2711  * We intentionally do not compare phexpr. Two PlaceHolderVars with the
2712  * same ID and levelsup should be considered equal even if the contained
2713  * expressions have managed to mutate to different states. This will
2714  * happen during final plan construction when there are nested PHVs, since
2715  * the inner PHV will get replaced by a Param in some copies of the outer
2716  * PHV. Another way in which it can happen is that initplan sublinks
2717  * could get replaced by differently-numbered Params when sublink folding
2718  * is done. (The end result of such a situation would be some
2719  * unreferenced initplans, which is annoying but not really a problem.)
2720  * On the same reasoning, there is no need to examine phrels. But we do
2721  * need to compare phnullingrels, as that represents effects that are
2722  * external to the original value of the PHV.
2723  */
2724 
2725 typedef struct PlaceHolderVar
2726 {
2728 
2729  /* the represented expression */
2730  Expr *phexpr pg_node_attr(equal_ignore);
2731 
2732  /* base+OJ relids syntactically within expr src */
2733  Relids phrels pg_node_attr(equal_ignore);
2734 
2735  /* RT indexes of outer joins that can null PHV's value */
2737 
2738  /* ID for PHV (unique within planner run) */
2740 
2741  /* > 0 if PHV belongs to outer query */
2744 
2745 /*
2746  * "Special join" info.
2747  *
2748  * One-sided outer joins constrain the order of joining partially but not
2749  * completely. We flatten such joins into the planner's top-level list of
2750  * relations to join, but record information about each outer join in a
2751  * SpecialJoinInfo struct. These structs are kept in the PlannerInfo node's
2752  * join_info_list.
2753  *
2754  * Similarly, semijoins and antijoins created by flattening IN (subselect)
2755  * and EXISTS(subselect) clauses create partial constraints on join order.
2756  * These are likewise recorded in SpecialJoinInfo structs.
2757  *
2758  * We make SpecialJoinInfos for FULL JOINs even though there is no flexibility
2759  * of planning for them, because this simplifies make_join_rel()'s API.
2760  *
2761  * min_lefthand and min_righthand are the sets of base+OJ relids that must be
2762  * available on each side when performing the special join.
2763  * It is not valid for either min_lefthand or min_righthand to be empty sets;
2764  * if they were, this would break the logic that enforces join order.
2765  *
2766  * syn_lefthand and syn_righthand are the sets of base+OJ relids that are
2767  * syntactically below this special join. (These are needed to help compute
2768  * min_lefthand and min_righthand for higher joins.)
2769  *
2770  * jointype is never JOIN_RIGHT; a RIGHT JOIN is handled by switching
2771  * the inputs to make it a LEFT JOIN. So the allowed values of jointype
2772  * in a join_info_list member are only LEFT, FULL, SEMI, or ANTI.
2773  *
2774  * ojrelid is the RT index of the join RTE representing this outer join,
2775  * if there is one. It is zero when jointype is INNER or SEMI, and can be
2776  * zero for jointype ANTI (if the join was transformed from a SEMI join).
2777  * One use for this field is that when constructing the output targetlist of a
2778  * join relation that implements this OJ, we add ojrelid to the varnullingrels
2779  * and phnullingrels fields of nullable (RHS) output columns, so that the
2780  * output Vars and PlaceHolderVars correctly reflect the nulling that has
2781  * potentially happened to them.
2782  *
2783  * commute_above_l is filled with the relids of syntactically-higher outer
2784  * joins that have been found to commute with this one per outer join identity
2785  * 3 (see optimizer/README), when this join is in the LHS of the upper join
2786  * (so, this is the lower join in the first form of the identity).
2787  *
2788  * commute_above_r is filled with the relids of syntactically-higher outer
2789  * joins that have been found to commute with this one per outer join identity
2790  * 3, when this join is in the RHS of the upper join (so, this is the lower
2791  * join in the second form of the identity).
2792  *
2793  * commute_below is filled with the relids of syntactically-lower outer joins
2794  * that have been found to commute with this one per outer join identity 3.
2795  * (We need not record which side they are on, since that can be determined
2796  * by seeing whether the lower join's relid appears in syn_lefthand or
2797  * syn_righthand.)
2798  *
2799  * lhs_strict is true if the special join's condition cannot succeed when the
2800  * LHS variables are all NULL (this means that an outer join can commute with
2801  * upper-level outer joins even if it appears in their RHS). We don't bother
2802  * to set lhs_strict for FULL JOINs, however.
2803  *
2804  * For a semijoin, we also extract the join operators and their RHS arguments
2805  * and set semi_operators, semi_rhs_exprs, semi_can_btree, and semi_can_hash.
2806  * This is done in support of possibly unique-ifying the RHS, so we don't
2807  * bother unless at least one of semi_can_btree and semi_can_hash can be set
2808  * true. (You might expect that this information would be computed during
2809  * join planning; but it's helpful to have it available during planning of
2810  * parameterized table scans, so we store it in the SpecialJoinInfo structs.)
2811  *
2812  * For purposes of join selectivity estimation, we create transient
2813  * SpecialJoinInfo structures for regular inner joins; so it is possible
2814  * to have jointype == JOIN_INNER in such a structure, even though this is
2815  * not allowed within join_info_list. We also create transient
2816  * SpecialJoinInfos with jointype == JOIN_INNER for outer joins, since for
2817  * cost estimation purposes it is sometimes useful to know the join size under
2818  * plain innerjoin semantics. Note that lhs_strict and the semi_xxx fields
2819  * are not set meaningfully within such structs.
2820  */
2821 #ifndef HAVE_SPECIALJOININFO_TYPEDEF
2822 typedef struct SpecialJoinInfo SpecialJoinInfo;
2823 #define HAVE_SPECIALJOININFO_TYPEDEF 1
2824 #endif
2825 
2827 {
2828  pg_node_attr(no_read)
2829 
2830  NodeTag type;
2831  Relids min_lefthand; /* base+OJ relids in minimum LHS for join */
2832  Relids min_righthand; /* base+OJ relids in minimum RHS for join */
2833  Relids syn_lefthand; /* base+OJ relids syntactically within LHS */
2834  Relids syn_righthand; /* base+OJ relids syntactically within RHS */
2835  JoinType jointype; /* always INNER, LEFT, FULL, SEMI, or ANTI */
2836  Index ojrelid; /* outer join's RT index; 0 if none */
2837  Relids commute_above_l; /* commuting OJs above this one, if LHS */
2838  Relids commute_above_r; /* commuting OJs above this one, if RHS */
2839  Relids commute_below; /* commuting OJs below this one */
2840  bool lhs_strict; /* joinclause is strict for some LHS rel */
2841  /* Remaining fields are set only for JOIN_SEMI jointype: */
2842  bool semi_can_btree; /* true if semi_operators are all btree */
2843  bool semi_can_hash; /* true if semi_operators are all hash */
2844  List *semi_operators; /* OIDs of equality join operators */
2845  List *semi_rhs_exprs; /* righthand-side expressions of these ops */
2846 };
2847 
2848 /*
2849  * Transient outer-join clause info.
2850  *
2851  * We set aside every outer join ON clause that looks mergejoinable,
2852  * and process it specially at the end of qual distribution.
2853  */
2854 typedef struct OuterJoinClauseInfo
2855 {
2856  pg_node_attr(no_copy_equal, no_read)
2857 
2858  NodeTag type;
2859  RestrictInfo *rinfo; /* a mergejoinable outer-join clause */
2860  SpecialJoinInfo *sjinfo; /* the outer join's SpecialJoinInfo */
2862 
2863 /*
2864  * Append-relation info.
2865  *
2866  * When we expand an inheritable table or a UNION-ALL subselect into an
2867  * "append relation" (essentially, a list of child RTEs), we build an
2868  * AppendRelInfo for each child RTE. The list of AppendRelInfos indicates
2869  * which child RTEs must be included when expanding the parent, and each node
2870  * carries information needed to translate between columns of the parent and
2871  * columns of the child.
2872  *
2873  * These structs are kept in the PlannerInfo node's append_rel_list, with
2874  * append_rel_array[] providing a convenient lookup method for the struct
2875  * associated with a particular child relid (there can be only one, though
2876  * parent rels may have many entries in append_rel_list).
2877  *
2878  * Note: after completion of the planner prep phase, any given RTE is an
2879  * append parent having entries in append_rel_list if and only if its
2880  * "inh" flag is set. We clear "inh" for plain tables that turn out not
2881  * to have inheritance children, and (in an abuse of the original meaning
2882  * of the flag) we set "inh" for subquery RTEs that turn out to be
2883  * flattenable UNION ALL queries. This lets us avoid useless searches
2884  * of append_rel_list.
2885  *
2886  * Note: the data structure assumes that append-rel members are single
2887  * baserels. This is OK for inheritance, but it prevents us from pulling
2888  * up a UNION ALL member subquery if it contains a join. While that could
2889  * be fixed with a more complex data structure, at present there's not much
2890  * point because no improvement in the plan could result.
2891  */
2892 
2893 typedef struct AppendRelInfo
2894 {
2896 
2897  /*
2898  * These fields uniquely identify this append relationship. There can be
2899  * (in fact, always should be) multiple AppendRelInfos for the same
2900  * parent_relid, but never more than one per child_relid, since a given
2901  * RTE cannot be a child of more than one append parent.
2902  */
2903  Index parent_relid; /* RT index of append parent rel */
2904  Index child_relid; /* RT index of append child rel */
2905 
2906  /*
2907  * For an inheritance appendrel, the parent and child are both regular
2908  * relations, and we store their rowtype OIDs here for use in translating
2909  * whole-row Vars. For a UNION-ALL appendrel, the parent and child are
2910  * both subqueries with no named rowtype, and we store InvalidOid here.
2911  */
2912  Oid parent_reltype; /* OID of parent's composite type */
2913  Oid child_reltype; /* OID of child's composite type */
2914 
2915  /*
2916  * The N'th element of this list is a Var or expression representing the
2917  * child column corresponding to the N'th column of the parent. This is
2918  * used to translate Vars referencing the parent rel into references to
2919  * the child. A list element is NULL if it corresponds to a dropped
2920  * column of the parent (this is only possible for inheritance cases, not
2921  * UNION ALL). The list elements are always simple Vars for inheritance
2922  * cases, but can be arbitrary expressions in UNION ALL cases.
2923  *
2924  * Notice we only store entries for user columns (attno > 0). Whole-row
2925  * Vars are special-cased, and system columns (attno < 0) need no special
2926  * translation since their attnos are the same for all tables.
2927  *
2928  * Caution: the Vars have varlevelsup = 0. Be careful to adjust as needed
2929  * when copying into a subquery.
2930  */
2931  List *translated_vars; /* Expressions in the child's Vars */
2932 
2933  /*
2934  * This array simplifies translations in the reverse direction, from
2935  * child's column numbers to parent's. The entry at [ccolno - 1] is the
2936  * 1-based parent column number for child column ccolno, or zero if that
2937  * child column is dropped or doesn't exist in the parent.
2938  */
2939  int num_child_cols; /* length of array */
2940  AttrNumber *parent_colnos pg_node_attr(array_size(num_child_cols));
2941 
2942  /*
2943  * We store the parent table's OID here for inheritance, or InvalidOid for
2944  * UNION ALL. This is only needed to help in generating error messages if
2945  * an attempt is made to reference a dropped parent column.
2946  */
2947  Oid parent_reloid; /* OID of parent relation */
2949 
2950 /*
2951  * Information about a row-identity "resjunk" column in UPDATE/DELETE/MERGE.
2952  *
2953  * In partitioned UPDATE/DELETE/MERGE it's important for child partitions to
2954  * share row-identity columns whenever possible, so as not to chew up too many
2955  * targetlist columns. We use these structs to track which identity columns
2956  * have been requested. In the finished plan, each of these will give rise
2957  * to one resjunk entry in the targetlist of the ModifyTable's subplan node.
2958  *
2959  * All the Vars stored in RowIdentityVarInfos must have varno ROWID_VAR, for
2960  * convenience of detecting duplicate requests. We'll replace that, in the
2961  * final plan, with the varno of the generating rel.
2962  *
2963  * Outside this list, a Var with varno ROWID_VAR and varattno k is a reference
2964  * to the k-th element of the row_identity_vars list (k counting from 1).
2965  * We add such a reference to root->processed_tlist when creating the entry,
2966  * and it propagates into the plan tree from there.
2967  */
2968 typedef struct RowIdentityVarInfo
2969 {
2970  pg_node_attr(no_copy_equal, no_read)
2971 
2972  NodeTag type;
2973 
2974  Var *rowidvar; /* Var to be evaluated (but varno=ROWID_VAR) */
2975  int32 rowidwidth; /* estimated average width */
2976  char *rowidname; /* name of the resjunk column */
2977  Relids rowidrels; /* RTE indexes of target rels using this */
2979 
2980 /*
2981  * For each distinct placeholder expression generated during planning, we
2982  * store a PlaceHolderInfo node in the PlannerInfo node's placeholder_list.
2983  * This stores info that is needed centrally rather than in each copy of the
2984  * PlaceHolderVar. The phid fields identify which PlaceHolderInfo goes with
2985  * each PlaceHolderVar. Note that phid is unique throughout a planner run,
2986  * not just within a query level --- this is so that we need not reassign ID's
2987  * when pulling a subquery into its parent.
2988  *
2989  * The idea is to evaluate the expression at (only) the ph_eval_at join level,
2990  * then allow it to bubble up like a Var until the ph_needed join level.
2991  * ph_needed has the same definition as attr_needed for a regular Var.
2992  *
2993  * The PlaceHolderVar's expression might contain LATERAL references to vars
2994  * coming from outside its syntactic scope. If so, those rels are *not*
2995  * included in ph_eval_at, but they are recorded in ph_lateral.
2996  *
2997  * Notice that when ph_eval_at is a join rather than a single baserel, the
2998  * PlaceHolderInfo may create constraints on join order: the ph_eval_at join
2999  * has to be formed below any outer joins that should null the PlaceHolderVar.
3000  *
3001  * We create a PlaceHolderInfo only after determining that the PlaceHolderVar
3002  * is actually referenced in the plan tree, so that unreferenced placeholders
3003  * don't result in unnecessary constraints on join order.
3004  */
3005 
3006 typedef struct PlaceHolderInfo
3007 {
3008  pg_node_attr(no_read)
3009 
3010  NodeTag type;
3011 
3012  /* ID for PH (unique within planner run) */
3014 
3015  /*
3016  * copy of PlaceHolderVar tree (should be redundant for comparison, could
3017  * be ignored)
3018  */
3020 
3021  /* lowest level we can evaluate value at */
3023 
3024  /* relids of contained lateral refs, if any */
3026 
3027  /* highest level the value is needed at */
3029 
3030  /* estimated attribute width */
3033 
3034 /*
3035  * This struct describes one potentially index-optimizable MIN/MAX aggregate
3036  * function. MinMaxAggPath contains a list of these, and if we accept that
3037  * path, the list is stored into root->minmax_aggs for use during setrefs.c.
3038  */
3039 typedef struct MinMaxAggInfo
3040 {
3041  pg_node_attr(no_copy_equal, no_read)
3042 
3043  NodeTag type;
3044 
3045  /* pg_proc Oid of the aggregate */
3047 
3048  /* Oid of its sort operator */
3050 
3051  /* expression we are aggregating on */
3053 
3054  /*
3055  * modified "root" for planning the subquery; not printed, too large, not
3056  * interesting enough
3057  */
3058  PlannerInfo *subroot pg_node_attr(read_write_ignore);
3059 
3060  /* access path for subquery */
3062 
3063  /* estimated cost to fetch first row */
3065 
3066  /* param for subplan's output */
3069 
3070 /*
3071  * At runtime, PARAM_EXEC slots are used to pass values around from one plan
3072  * node to another. They can be used to pass values down into subqueries (for
3073  * outer references in subqueries), or up out of subqueries (for the results
3074  * of a subplan), or from a NestLoop plan node into its inner relation (when
3075  * the inner scan is parameterized with values from the outer relation).
3076  * The planner is responsible for assigning nonconflicting PARAM_EXEC IDs to
3077  * the PARAM_EXEC Params it generates.
3078  *
3079  * Outer references are managed via root->plan_params, which is a list of
3080  * PlannerParamItems. While planning a subquery, each parent query level's
3081  * plan_params contains the values required from it by the current subquery.
3082  * During create_plan(), we use plan_params to track values that must be
3083  * passed from outer to inner sides of NestLoop plan nodes.
3084  *
3085  * The item a PlannerParamItem represents can be one of three kinds:
3086  *
3087  * A Var: the slot represents a variable of this level that must be passed
3088  * down because subqueries have outer references to it, or must be passed
3089  * from a NestLoop node to its inner scan. The varlevelsup value in the Var
3090  * will always be zero.
3091  *
3092  * A PlaceHolderVar: this works much like the Var case, except that the
3093  * entry is a PlaceHolderVar node with a contained expression. The PHV
3094  * will have phlevelsup = 0, and the contained expression is adjusted
3095  * to match in level.
3096  *
3097  * An Aggref (with an expression tree representing its argument): the slot
3098  * represents an aggregate expression that is an outer reference for some
3099  * subquery. The Aggref itself has agglevelsup = 0, and its argument tree
3100  * is adjusted to match in level.
3101  *
3102  * Note: we detect duplicate Var and PlaceHolderVar parameters and coalesce
3103  * them into one slot, but we do not bother to do that for Aggrefs.
3104  * The scope of duplicate-elimination only extends across the set of
3105  * parameters passed from one query level into a single subquery, or for
3106  * nestloop parameters across the set of nestloop parameters used in a single
3107  * query level. So there is no possibility of a PARAM_EXEC slot being used
3108  * for conflicting purposes.
3109  *
3110  * In addition, PARAM_EXEC slots are assigned for Params representing outputs
3111  * from subplans (values that are setParam items for those subplans). These
3112  * IDs need not be tracked via PlannerParamItems, since we do not need any
3113  * duplicate-elimination nor later processing of the represented expressions.
3114  * Instead, we just record the assignment of the slot number by appending to
3115  * root->glob->paramExecTypes.
3116  */
3117 typedef struct PlannerParamItem
3118 {
3119  pg_node_attr(no_copy_equal, no_read)
3120 
3121  NodeTag type;
3122 
3123  Node *item; /* the Var, PlaceHolderVar, or Aggref */
3124  int paramId; /* its assigned PARAM_EXEC slot number */
3126 
3127 /*
3128  * When making cost estimates for a SEMI/ANTI/inner_unique join, there are
3129  * some correction factors that are needed in both nestloop and hash joins
3130  * to account for the fact that the executor can stop scanning inner rows
3131  * as soon as it finds a match to the current outer row. These numbers
3132  * depend only on the selected outer and inner join relations, not on the
3133  * particular paths used for them, so it's worthwhile to calculate them
3134  * just once per relation pair not once per considered path. This struct
3135  * is filled by compute_semi_anti_join_factors and must be passed along
3136  * to the join cost estimation functions.
3137  *
3138  * outer_match_frac is the fraction of the outer tuples that are
3139  * expected to have at least one match.
3140  * match_count is the average number of matches expected for
3141  * outer tuples that have at least one match.
3142  */
3143 typedef struct SemiAntiJoinFactors
3144 {
3148 
3149 /*
3150  * Struct for extra information passed to subroutines of add_paths_to_joinrel
3151  *
3152  * restrictlist contains all of the RestrictInfo nodes for restriction
3153  * clauses that apply to this join
3154  * mergeclause_list is a list of RestrictInfo nodes for available
3155  * mergejoin clauses in this join
3156  * inner_unique is true if each outer tuple provably matches no more
3157  * than one inner tuple
3158  * sjinfo is extra info about special joins for selectivity estimation
3159  * semifactors is as shown above (only valid for SEMI/ANTI/inner_unique joins)
3160  * param_source_rels are OK targets for parameterization of result paths
3161  */
3162 typedef struct JoinPathExtraData
3163 {
3171 
3172 /*
3173  * Various flags indicating what kinds of grouping are possible.
3174  *
3175  * GROUPING_CAN_USE_SORT should be set if it's possible to perform
3176  * sort-based implementations of grouping. When grouping sets are in use,
3177  * this will be true if sorting is potentially usable for any of the grouping
3178  * sets, even if it's not usable for all of them.
3179  *
3180  * GROUPING_CAN_USE_HASH should be set if it's possible to perform
3181  * hash-based implementations of grouping.
3182  *
3183  * GROUPING_CAN_PARTIAL_AGG should be set if the aggregation is of a type
3184  * for which we support partial aggregation (not, for example, grouping sets).
3185  * It says nothing about parallel-safety or the availability of suitable paths.
3186  */
3187 #define GROUPING_CAN_USE_SORT 0x0001
3188 #define GROUPING_CAN_USE_HASH 0x0002
3189 #define GROUPING_CAN_PARTIAL_AGG 0x0004
3190 
3191 /*
3192  * What kind of partitionwise aggregation is in use?
3193  *
3194  * PARTITIONWISE_AGGREGATE_NONE: Not used.
3195  *
3196  * PARTITIONWISE_AGGREGATE_FULL: Aggregate each partition separately, and
3197  * append the results.
3198  *
3199  * PARTITIONWISE_AGGREGATE_PARTIAL: Partially aggregate each partition
3200  * separately, append the results, and then finalize aggregation.
3201  */
3202 typedef enum
3203 {
3208 
3209 /*
3210  * Struct for extra information passed to subroutines of create_grouping_paths
3211  *
3212  * flags indicating what kinds of grouping are possible.
3213  * partial_costs_set is true if the agg_partial_costs and agg_final_costs
3214  * have been initialized.
3215  * agg_partial_costs gives partial aggregation costs.
3216  * agg_final_costs gives finalization costs.
3217  * target_parallel_safe is true if target is parallel safe.
3218  * havingQual gives list of quals to be applied after aggregation.
3219  * targetList gives list of columns to be projected.
3220  * patype is the type of partitionwise aggregation that is being performed.
3221  */
3222 typedef struct
3223 {
3224  /* Data which remains constant once set. */
3225  int flags;
3229 
3230  /* Data which may differ across partitions. */
3236 
3237 /*
3238  * Struct for extra information passed to subroutines of grouping_planner
3239  *
3240  * limit_needed is true if we actually need a Limit plan node.
3241  * limit_tuples is an estimated bound on the number of output tuples,
3242  * or -1 if no LIMIT or couldn't estimate.
3243  * count_est and offset_est are the estimated values of the LIMIT and OFFSET
3244  * expressions computed by preprocess_limit() (see comments for
3245  * preprocess_limit() for more information).
3246  */
3247 typedef struct
3248 {
3251  int64 count_est;
3252  int64 offset_est;
3254 
3255 /*
3256  * For speed reasons, cost estimation for join paths is performed in two
3257  * phases: the first phase tries to quickly derive a lower bound for the
3258  * join cost, and then we check if that's sufficient to reject the path.
3259  * If not, we come back for a more refined cost estimate. The first phase
3260  * fills a JoinCostWorkspace struct with its preliminary cost estimates
3261  * and possibly additional intermediate values. The second phase takes
3262  * these values as inputs to avoid repeating work.
3263  *
3264  * (Ideally we'd declare this in cost.h, but it's also needed in pathnode.h,
3265  * so seems best to put it here.)
3266  */
3267 typedef struct JoinCostWorkspace
3268 {
3269  /* Preliminary cost estimates --- must not be larger than final ones! */
3270  Cost startup_cost; /* cost expended before fetching any tuples */
3271  Cost total_cost; /* total cost (assuming all tuples fetched) */
3272 
3273  /* Fields below here should be treated as private to costsize.c */
3274  Cost run_cost; /* non-startup cost components */
3275 
3276  /* private for cost_nestloop code */
3277  Cost inner_run_cost; /* also used by cost_mergejoin code */
3279 
3280  /* private for cost_mergejoin code */
3285 
3286  /* private for cost_hashjoin code */
3291 
3292 /*
3293  * AggInfo holds information about an aggregate that needs to be computed.
3294  * Multiple Aggrefs in a query can refer to the same AggInfo by having the
3295  * same 'aggno' value, so that the aggregate is computed only once.
3296  */
3297 typedef struct AggInfo
3298 {
3299  pg_node_attr(no_copy_equal, no_read)
3300 
3301  NodeTag type;
3302 
3303  /*
3304  * List of Aggref exprs that this state value is for.
3305  *
3306  * There will always be at least one, but there can be multiple identical
3307  * Aggref's sharing the same per-agg.
3308  */
3310 
3311  /* Transition state number for this aggregate */
3312  int transno;
3313 
3314  /*
3315  * "shareable" is false if this agg cannot share state values with other
3316  * aggregates because the final function is read-write.
3317  */
3319 
3320  /* Oid of the final function, or InvalidOid if none */
3323 
3324 /*
3325  * AggTransInfo holds information about transition state that is used by one
3326  * or more aggregates in the query. Multiple aggregates can share the same
3327  * transition state, if they have the same inputs and the same transition
3328  * function. Aggrefs that share the same transition info have the same
3329  * 'aggtransno' value.
3330  */
3331 typedef struct AggTransInfo
3332 {
3333  pg_node_attr(no_copy_equal, no_read)
3334 
3335  NodeTag type;
3336 
3337  /* Inputs for this transition state */
3340 
3341  /* Oid of the state transition function */
3343 
3344  /* Oid of the serialization function, or InvalidOid if none */
3346 
3347  /* Oid of the deserialization function, or InvalidOid if none */
3349 
3350  /* Oid of the combine function, or InvalidOid if none */
3352 
3353  /* Oid of state value's datatype */
3355 
3356  /* Additional data about transtype */
3360 
3361  /* Space-consumption estimate */
3363 
3364  /* Initial value from pg_aggregate entry */
3365  Datum initValue pg_node_attr(read_write_ignore);
3368 
3369 #endif /* PATHNODES_H */
int16 AttrNumber
Definition: attnum.h:21
uint32 BlockNumber
Definition: block.h:31
unsigned int uint32
Definition: c.h:490
signed short int16
Definition: c.h:477
signed int int32
Definition: c.h:478
unsigned int Index
Definition: c.h:598
size_t Size
Definition: c.h:589
static int initValue(long lng_val)
Definition: informix.c:677
SetOpCmd
Definition: nodes.h:405
SetOpStrategy
Definition: nodes.h:413
double Cost
Definition: nodes.h:262
double Cardinality
Definition: nodes.h:263
CmdType
Definition: nodes.h:274
AggStrategy
Definition: nodes.h:361
NodeTag
Definition: nodes.h:27
double Selectivity
Definition: nodes.h:261
AggSplit
Definition: nodes.h:383
LimitOption
Definition: nodes.h:438
JoinType
Definition: nodes.h:299
RTEKind
Definition: parsenodes.h:1012
struct AggTransInfo AggTransInfo
struct MergeScanSelCache MergeScanSelCache
struct IndexPath IndexPath
struct TidRangePath TidRangePath
struct JoinCostWorkspace JoinCostWorkspace
bool is_dummy_rel(RelOptInfo *rel)
Definition: joinrels.c:1222
PartitionwiseAggregateType
Definition: pathnodes.h:3203
@ PARTITIONWISE_AGGREGATE_PARTIAL
Definition: pathnodes.h:3206
@ PARTITIONWISE_AGGREGATE_FULL
Definition: pathnodes.h:3205
@ PARTITIONWISE_AGGREGATE_NONE
Definition: pathnodes.h:3204
struct ForeignPath ForeignPath
struct OuterJoinClauseInfo OuterJoinClauseInfo
struct StatisticExtInfo StatisticExtInfo
struct SetOpPath SetOpPath
struct Path Path
struct RollupData RollupData
struct BitmapOrPath BitmapOrPath
UniquePathMethod
Definition: pathnodes.h:1984
@ UNIQUE_PATH_SORT
Definition: pathnodes.h:1987
@ UNIQUE_PATH_NOOP
Definition: pathnodes.h:1985
@ UNIQUE_PATH_HASH
Definition: pathnodes.h:1986
struct PlannerGlobal PlannerGlobal
struct ParamPathInfo ParamPathInfo
struct PathKey PathKey
struct SubqueryScanPath SubqueryScanPath
struct HashPath HashPath
struct UniquePath UniquePath
CostSelector
Definition: pathnodes.h:37
@ TOTAL_COST
Definition: pathnodes.h:38
@ STARTUP_COST
Definition: pathnodes.h:38
struct AggClauseCosts AggClauseCosts
struct EquivalenceClass EquivalenceClass
VolatileFunctionStatus
Definition: pathnodes.h:1475
@ VOLATILITY_NOVOLATILE
Definition: pathnodes.h:1478
@ VOLATILITY_UNKNOWN
Definition: pathnodes.h:1476
@ VOLATILITY_VOLATILE
Definition: pathnodes.h:1477
Bitmapset * Relids
Definition: pathnodes.h:30
struct RecursiveUnionPath RecursiveUnionPath
struct SortPath SortPath
struct EquivalenceMember EquivalenceMember
struct MaterialPath MaterialPath
struct AppendRelInfo AppendRelInfo
struct PartitionSchemeData PartitionSchemeData
struct ProjectionPath ProjectionPath
struct CustomPath CustomPath
struct BitmapAndPath BitmapAndPath
struct PartitionSchemeData * PartitionScheme
Definition: pathnodes.h:595
struct WindowAggPath WindowAggPath
struct NestPath NestPath
struct MinMaxAggInfo MinMaxAggInfo
struct AggPath AggPath
struct RelOptInfo RelOptInfo
struct GroupingSetsPath GroupingSetsPath
struct IncrementalSortPath IncrementalSortPath
struct ProjectSetPath ProjectSetPath
struct MergePath MergePath
struct LockRowsPath LockRowsPath
struct MergeAppendPath MergeAppendPath
struct TidPath TidPath
struct GroupPath GroupPath
struct GroupResultPath GroupResultPath
struct MemoizePath MemoizePath
UpperRelationKind
Definition: pathnodes.h:70
@ UPPERREL_SETOP
Definition: pathnodes.h:71
@ UPPERREL_GROUP_AGG
Definition: pathnodes.h:74
@ UPPERREL_FINAL
Definition: pathnodes.h:79
@ UPPERREL_DISTINCT
Definition: pathnodes.h:77
@ UPPERREL_PARTIAL_GROUP_AGG
Definition: pathnodes.h:72
@ UPPERREL_ORDERED
Definition: pathnodes.h:78
@ UPPERREL_WINDOW
Definition: pathnodes.h:75
@ UPPERREL_PARTIAL_DISTINCT
Definition: pathnodes.h:76
struct AggInfo AggInfo
struct PlaceHolderVar PlaceHolderVar
RelOptKind
Definition: pathnodes.h:820
@ RELOPT_BASEREL
Definition: pathnodes.h:821
@ RELOPT_OTHER_MEMBER_REL
Definition: pathnodes.h:823
@ RELOPT_UPPER_REL
Definition: pathnodes.h:825
@ RELOPT_JOINREL
Definition: pathnodes.h:822
@ RELOPT_OTHER_UPPER_REL
Definition: pathnodes.h:826
@ RELOPT_DEADREL
Definition: pathnodes.h:827
@ RELOPT_OTHER_JOINREL
Definition: pathnodes.h:824
struct RestrictInfo RestrictInfo
struct JoinPathExtraData JoinPathExtraData
struct ModifyTablePath ModifyTablePath
struct LimitPath LimitPath
struct GroupingSetData GroupingSetData
struct UpperUniquePath UpperUniquePath
struct MinMaxAggPath MinMaxAggPath
struct PlannerParamItem PlannerParamItem
struct ForeignKeyOptInfo ForeignKeyOptInfo
struct PathTarget PathTarget
struct IndexClause IndexClause
struct PlaceHolderInfo PlaceHolderInfo
struct QualCost QualCost
struct GatherPath GatherPath
struct SemiAntiJoinFactors SemiAntiJoinFactors
struct JoinDomain JoinDomain
struct RowIdentityVarInfo RowIdentityVarInfo
struct AppendPath AppendPath
struct GatherMergePath GatherMergePath
struct BitmapHeapPath BitmapHeapPath
#define INDEX_MAX_KEYS
#define NIL
Definition: pg_list.h:68
uintptr_t Datum
Definition: postgres.h:64
unsigned int Oid
Definition: postgres_ext.h:31
ScanDirection
Definition: sdir.h:25
QualCost finalCost
Definition: pathnodes.h:61
Size transitionSpace
Definition: pathnodes.h:62
QualCost transCost
Definition: pathnodes.h:60
bool shareable
Definition: pathnodes.h:3318
pg_node_attr(no_copy_equal, no_read) NodeTag type
List * aggrefs
Definition: pathnodes.h:3309
int transno
Definition: pathnodes.h:3312
Oid finalfn_oid
Definition: pathnodes.h:3321
Path * subpath
Definition: pathnodes.h:2219
Cardinality numGroups
Definition: pathnodes.h:2222
AggSplit aggsplit
Definition: pathnodes.h:2221
List * groupClause
Definition: pathnodes.h:2224
uint64 transitionSpace
Definition: pathnodes.h:2223
AggStrategy aggstrategy
Definition: pathnodes.h:2220
Path path
Definition: pathnodes.h:2218
List * qual
Definition: pathnodes.h:2225
List * args
Definition: pathnodes.h:3338
int32 aggtransspace
Definition: pathnodes.h:3362
bool transtypeByVal
Definition: pathnodes.h:3359
Oid combinefn_oid
Definition: pathnodes.h:3351
Oid deserialfn_oid
Definition: pathnodes.h:3348
int32 aggtranstypmod
Definition: pathnodes.h:3357
int transtypeLen
Definition: pathnodes.h:3358
pg_node_attr(no_copy_equal, no_read) NodeTag type
bool initValueIsNull
Definition: pathnodes.h:3366
Oid serialfn_oid
Definition: pathnodes.h:3345
Oid aggtranstype
Definition: pathnodes.h:3354
Expr * aggfilter
Definition: pathnodes.h:3339
Datum initValue pg_node_attr(read_write_ignore)
int first_partial_path
Definition: pathnodes.h:1899
Cardinality limit_tuples
Definition: pathnodes.h:1900
List * subpaths
Definition: pathnodes.h:1897
Index child_relid
Definition: pathnodes.h:2904
List * translated_vars
Definition: pathnodes.h:2931
NodeTag type
Definition: pathnodes.h:2895
Index parent_relid
Definition: pathnodes.h:2903
int num_child_cols
Definition: pathnodes.h:2939
AttrNumber *parent_colnos pg_node_attr(array_size(num_child_cols))
Oid parent_reltype
Definition: pathnodes.h:2912
Selectivity bitmapselectivity
Definition: pathnodes.h:1776
List * bitmapquals
Definition: pathnodes.h:1775
Path * bitmapqual
Definition: pathnodes.h:1763
Selectivity bitmapselectivity
Definition: pathnodes.h:1789
List * bitmapquals
Definition: pathnodes.h:1788
const struct CustomPathMethods * methods
Definition: pathnodes.h:1876
List * custom_paths
Definition: pathnodes.h:1874
uint32 flags
Definition: pathnodes.h:1872
List * custom_private
Definition: pathnodes.h:1875
Index ec_min_security
Definition: pathnodes.h:1389
List * ec_opfamilies
Definition: pathnodes.h:1378
pg_node_attr(custom_read_write, no_copy_equal, no_read) NodeTag type
struct EquivalenceClass * ec_merged
Definition: pathnodes.h:1391
Index ec_max_security
Definition: pathnodes.h:1390
JoinDomain * em_jdomain
Definition: pathnodes.h:1434
struct EquivalenceMember *em_parent pg_node_attr(read_write_ignore)
pg_node_attr(no_copy_equal, no_read) NodeTag type
Cardinality limit_tuples
Definition: pathnodes.h:3250
Definition: fmgr.h:57
AttrNumber confkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys))
struct EquivalenceClass * eclass[INDEX_MAX_KEYS]
Definition: pathnodes.h:1245
AttrNumber conkey[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys))
pg_node_attr(custom_read_write, no_copy_equal, no_read) NodeTag type
Oid conpfeqop[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys))
List * rinfos[INDEX_MAX_KEYS]
Definition: pathnodes.h:1249
struct EquivalenceMember * fk_eclass_member[INDEX_MAX_KEYS]
Definition: pathnodes.h:1247
Path * fdw_outerpath
Definition: pathnodes.h:1844
List * fdw_private
Definition: pathnodes.h:1845
bool single_copy
Definition: pathnodes.h:2008
Path * subpath
Definition: pathnodes.h:2007
int num_workers
Definition: pathnodes.h:2009
PartitionwiseAggregateType patype
Definition: pathnodes.h:3234
AggClauseCosts agg_final_costs
Definition: pathnodes.h:3228
AggClauseCosts agg_partial_costs
Definition: pathnodes.h:3227
List * qual
Definition: pathnodes.h:2193
List * groupClause
Definition: pathnodes.h:2192
Path * subpath
Definition: pathnodes.h:2191
Path path
Definition: pathnodes.h:2190
pg_node_attr(no_copy_equal, no_read) NodeTag type
Cardinality numGroups
Definition: pathnodes.h:2238
uint64 transitionSpace
Definition: pathnodes.h:2265
AggStrategy aggstrategy
Definition: pathnodes.h:2262
Definition: dynahash.c:220
List * path_hashclauses
Definition: pathnodes.h:2117
Cardinality inner_rows_total
Definition: pathnodes.h:2119
int num_batches
Definition: pathnodes.h:2118
JoinPath jpath
Definition: pathnodes.h:2116
AttrNumber indexcol
Definition: pathnodes.h:1739
pg_node_attr(no_copy_equal, no_read) NodeTag type
List * indexcols
Definition: pathnodes.h:1740
List * indexquals
Definition: pathnodes.h:1737
struct RestrictInfo * rinfo
Definition: pathnodes.h:1736
bool *reverse_sort pg_node_attr(array_size(nkeycolumns))
bool amcanparallel
Definition: pathnodes.h:1193
List *indexprs pg_node_attr(read_write_ignore)
Oid *sortopfamily pg_node_attr(array_size(nkeycolumns))
int *indexkeys pg_node_attr(array_size(ncolumns))
bool amoptionalkey
Definition: pathnodes.h:1186
Oid reltablespace
Definition: pathnodes.h:1108
pg_node_attr(no_copy_equal, no_read) NodeTag type
bool amcanmarkpos
Definition: pathnodes.h:1195
List * indrestrictinfo
Definition: pathnodes.h:1170
void(* amcostestimate)() pg_node_attr(read_write_ignore)
Definition: pathnodes.h:1198
RelOptInfo *rel pg_node_attr(read_write_ignore)
bool amhasgettuple
Definition: pathnodes.h:1190
bool amcanorderbyop
Definition: pathnodes.h:1185
Oid *opcintype pg_node_attr(array_size(nkeycolumns))
Oid *opfamily pg_node_attr(array_size(nkeycolumns))
bool hypothetical
Definition: pathnodes.h:1179
bytea **opclassoptions pg_node_attr(read_write_ignore)
bool *nulls_first pg_node_attr(array_size(nkeycolumns))
List * indpred
Definition: pathnodes.h:1160
Cardinality tuples
Definition: pathnodes.h:1118
bool amsearcharray
Definition: pathnodes.h:1187
BlockNumber pages
Definition: pathnodes.h:1116
bool amsearchnulls
Definition: pathnodes.h:1188
bool *canreturn pg_node_attr(array_size(ncolumns))
bool amhasgetbitmap
Definition: pathnodes.h:1192
List * indextlist
Definition: pathnodes.h:1163
bool immediate
Definition: pathnodes.h:1177
Oid *indexcollations pg_node_attr(array_size(nkeycolumns))
List * indexclauses
Definition: pathnodes.h:1689
ScanDirection indexscandir
Definition: pathnodes.h:1692
Path path
Definition: pathnodes.h:1687
List * indexorderbycols
Definition: pathnodes.h:1691
List * indexorderbys
Definition: pathnodes.h:1690
Selectivity indexselectivity
Definition: pathnodes.h:1694
Cost indextotalcost
Definition: pathnodes.h:1693
IndexOptInfo * indexinfo
Definition: pathnodes.h:1688
Cardinality inner_rows
Definition: pathnodes.h:3282
Cardinality outer_rows
Definition: pathnodes.h:3281
Cost inner_rescan_run_cost
Definition: pathnodes.h:3278
Cardinality inner_skip_rows
Definition: pathnodes.h:3284
Cardinality inner_rows_total
Definition: pathnodes.h:3289
Cardinality outer_skip_rows
Definition: pathnodes.h:3283
pg_node_attr(no_copy_equal, no_read) NodeTag type
Relids jd_relids
Definition: pathnodes.h:1316
List * mergeclause_list
Definition: pathnodes.h:3165
Relids param_source_rels
Definition: pathnodes.h:3169
SemiAntiJoinFactors semifactors
Definition: pathnodes.h:3168
SpecialJoinInfo * sjinfo
Definition: pathnodes.h:3167
pg_node_attr(abstract) Path path
Path * outerjoinpath
Definition: pathnodes.h:2039
Path * innerjoinpath
Definition: pathnodes.h:2040
JoinType jointype
Definition: pathnodes.h:2034
bool inner_unique
Definition: pathnodes.h:2036
List * joinrestrictinfo
Definition: pathnodes.h:2042
Path path
Definition: pathnodes.h:2362
Path * subpath
Definition: pathnodes.h:2363
LimitOption limitOption
Definition: pathnodes.h:2366
Node * limitOffset
Definition: pathnodes.h:2364
Node * limitCount
Definition: pathnodes.h:2365
Definition: pg_list.h:54
Path * subpath
Definition: pathnodes.h:2325
List * rowMarks
Definition: pathnodes.h:2326
Path * subpath
Definition: pathnodes.h:1947
bool singlerow
Definition: pathnodes.h:1961
List * hash_operators
Definition: pathnodes.h:1959
uint32 est_entries
Definition: pathnodes.h:1966
bool binary_mode
Definition: pathnodes.h:1963
Cardinality calls
Definition: pathnodes.h:1965
Path * subpath
Definition: pathnodes.h:1958
List * param_exprs
Definition: pathnodes.h:1960
Cardinality limit_tuples
Definition: pathnodes.h:1922
List * outersortkeys
Definition: pathnodes.h:2099
bool skip_mark_restore
Definition: pathnodes.h:2101
List * innersortkeys
Definition: pathnodes.h:2100
JoinPath jpath
Definition: pathnodes.h:2097
bool materialize_inner
Definition: pathnodes.h:2102
List * path_mergeclauses
Definition: pathnodes.h:2098
Selectivity leftstartsel
Definition: pathnodes.h:2687
Selectivity leftendsel
Definition: pathnodes.h:2688
Selectivity rightendsel
Definition: pathnodes.h:2690
Selectivity rightstartsel
Definition: pathnodes.h:2689
Param * param
Definition: pathnodes.h:3067
pg_node_attr(no_copy_equal, no_read) NodeTag type
Expr * target
Definition: pathnodes.h:3052
PlannerInfo *subroot pg_node_attr(read_write_ignore)
List * quals
Definition: pathnodes.h:2275
List * mmaggregates
Definition: pathnodes.h:2274
bool partColsUpdated
Definition: pathnodes.h:2345
List * returningLists
Definition: pathnodes.h:2349
List * resultRelations
Definition: pathnodes.h:2346
List * withCheckOptionLists
Definition: pathnodes.h:2348
List * updateColnosLists
Definition: pathnodes.h:2347
OnConflictExpr * onconflict
Definition: pathnodes.h:2351
CmdType operation
Definition: pathnodes.h:2341
Index rootRelation
Definition: pathnodes.h:2344
Index nominalRelation
Definition: pathnodes.h:2343
List * mergeActionLists
Definition: pathnodes.h:2353
JoinPath jpath
Definition: pathnodes.h:2057
Definition: nodes.h:129
RestrictInfo * rinfo
Definition: pathnodes.h:2859
SpecialJoinInfo * sjinfo
Definition: pathnodes.h:2860
pg_node_attr(no_copy_equal, no_read) NodeTag type
Cardinality ppi_rows
Definition: pathnodes.h:1558
List * ppi_clauses
Definition: pathnodes.h:1559
pg_node_attr(no_copy_equal, no_read) NodeTag type
Bitmapset * ppi_serials
Definition: pathnodes.h:1560
Relids ppi_req_outer
Definition: pathnodes.h:1557
struct FmgrInfo * partsupfunc
Definition: pathnodes.h:592
bool pk_nulls_first
Definition: pathnodes.h:1466
int pk_strategy
Definition: pathnodes.h:1465
pg_node_attr(no_read) NodeTag type
EquivalenceClass *pk_eclass pg_node_attr(copy_as_scalar, equal_as_scalar)
Oid pk_opfamily
Definition: pathnodes.h:1464
pg_node_attr(no_copy_equal, no_read) NodeTag type
VolatileFunctionStatus has_volatile_expr
Definition: pathnodes.h:1523
Index *sortgrouprefs pg_node_attr(array_size(exprs))
List * exprs
Definition: pathnodes.h:1511
QualCost cost
Definition: pathnodes.h:1517
ParamPathInfo *param_info pg_node_attr(write_only_req_outer)
List * pathkeys
Definition: pathnodes.h:1643
PathTarget *pathtarget pg_node_attr(write_only_nondefault_pathtarget)
NodeTag pathtype
Definition: pathnodes.h:1604
Cardinality rows
Definition: pathnodes.h:1638
Cost startup_cost
Definition: pathnodes.h:1639
int parallel_workers
Definition: pathnodes.h:1635
pg_node_attr(no_copy_equal, no_read) NodeTag type
RelOptInfo *parent pg_node_attr(write_only_relids)
Cost total_cost
Definition: pathnodes.h:1640
bool parallel_aware
Definition: pathnodes.h:1631
bool parallel_safe
Definition: pathnodes.h:1633
pg_node_attr(no_read) NodeTag type
Relids ph_lateral
Definition: pathnodes.h:3025
Relids ph_needed
Definition: pathnodes.h:3028
Relids ph_eval_at
Definition: pathnodes.h:3022
PlaceHolderVar * ph_var
Definition: pathnodes.h:3019
Relids phrels pg_node_attr(equal_ignore)
Relids phnullingrels
Definition: pathnodes.h:2736
Expr *phexpr pg_node_attr(equal_ignore)
Index phlevelsup
Definition: pathnodes.h:2742
int lastPlanNodeId
Definition: pathnodes.h:147
char maxParallelHazard
Definition: pathnodes.h:162
List * subplans
Definition: pathnodes.h:105
pg_node_attr(no_copy_equal, no_read) NodeTag type
PartitionDirectory partition_directory pg_node_attr(read_write_ignore)
bool dependsOnRole
Definition: pathnodes.h:153
List * appendRelations
Definition: pathnodes.h:126
List * finalrowmarks
Definition: pathnodes.h:120
List * invalItems
Definition: pathnodes.h:135
List * relationOids
Definition: pathnodes.h:132
List * paramExecTypes
Definition: pathnodes.h:138
bool parallelModeOK
Definition: pathnodes.h:156
bool transientPlan
Definition: pathnodes.h:150
Bitmapset * rewindPlanIDs
Definition: pathnodes.h:111
List * finalrteperminfos
Definition: pathnodes.h:117
List *subroots pg_node_attr(read_write_ignore)
Index lastPHId
Definition: pathnodes.h:141
Index lastRowMarkId
Definition: pathnodes.h:144
List * resultRelations
Definition: pathnodes.h:123
List * partPruneInfos
Definition: pathnodes.h:129
List * finalrtable
Definition: pathnodes.h:114
ParamListInfo boundParams pg_node_attr(read_write_ignore)
bool parallelModeNeeded
Definition: pathnodes.h:159
int num_groupby_pathkeys
Definition: pathnodes.h:395
List * minmax_aggs
Definition: pathnodes.h:472
bool partColsUpdated
Definition: pathnodes.h:549
PlannerInfo *parent_root pg_node_attr(read_write_ignore)
struct RelOptInfo **simple_rel_array pg_node_attr(array_size(simple_rel_array_size))
List * canon_pathkeys
Definition: pathnodes.h:320
List * aggtransinfos
Definition: pathnodes.h:512
bool hasJoinRTEs
Definition: pathnodes.h:492
List * processed_tlist
Definition: pathnodes.h:456
List *part_schemes pg_node_attr(read_write_ignore)
List * distinct_pathkeys
Definition: pathnodes.h:400
List * join_rel_list
Definition: pathnodes.h:280
struct AppendRelInfo **append_rel_array pg_node_attr(read_write_ignore)
bool hasRecursion
Definition: pathnodes.h:504
int simple_rel_array_size
Definition: pathnodes.h:232
Relids all_query_rels
Definition: pathnodes.h:269
Relids curOuterRels
Definition: pathnodes.h:532
int numOrderedAggs
Definition: pathnodes.h:514
Relids outer_join_rels
Definition: pathnodes.h:261
List * cte_plan_ids
Definition: pathnodes.h:305
RangeTblEntry **simple_rte_array pg_node_attr(read_write_ignore)
int last_rinfo_serial
Definition: pathnodes.h:343
bool *isUsedSubplan pg_node_attr(read_write_ignore)
bool hasNonPartialAggs
Definition: pathnodes.h:516
bool hasLateralRTEs
Definition: pathnodes.h:494
Index qual_security_level
Definition: pathnodes.h:489
List * init_plans
Definition: pathnodes.h:299
List * multiexpr_params
Definition: pathnodes.h:308
List * row_identity_vars
Definition: pathnodes.h:368
bool hasHavingQual
Definition: pathnodes.h:496
bool ec_merging_done
Definition: pathnodes.h:317
List * left_join_clauses
Definition: pathnodes.h:326
List * full_join_clauses
Definition: pathnodes.h:337
struct HTAB *join_rel_hash pg_node_attr(read_write_ignore)
Bitmapset * outer_params
Definition: pathnodes.h:221
Index query_level
Definition: pathnodes.h:208
List * append_rel_list
Definition: pathnodes.h:365
struct Path * non_recursive_path
Definition: pathnodes.h:526
List * placeholder_list
Definition: pathnodes.h:374
pg_node_attr(no_copy_equal, no_read) NodeTag type
List * sort_pathkeys
Definition: pathnodes.h:402
PlannerGlobal * glob
Definition: pathnodes.h:205
List * join_domains
Definition: pathnodes.h:311
List * eq_classes
Definition: pathnodes.h:314
MemoryContext planner_cxt pg_node_attr(read_write_ignore)
List * group_pathkeys
Definition: pathnodes.h:388
List **join_rel_level pg_node_attr(read_write_ignore)
int wt_param_id
Definition: pathnodes.h:524
List * agginfos
Definition: pathnodes.h:510
List * plan_params
Definition: pathnodes.h:220
List * window_pathkeys
Definition: pathnodes.h:398
List * processed_groupClause
Definition: pathnodes.h:433
List * curOuterParams
Definition: pathnodes.h:534
bool hasAlternativeSubPlans
Definition: pathnodes.h:500
List * right_join_clauses
Definition: pathnodes.h:332
List *initial_rels pg_node_attr(read_write_ignore)
List * partPruneInfos
Definition: pathnodes.h:552
AttrNumber *grouping_map pg_node_attr(read_write_ignore)
bool hasNonSerialAggs
Definition: pathnodes.h:518
List * fkey_list
Definition: pathnodes.h:382
List * processed_distinctClause
Definition: pathnodes.h:445
bool *isAltSubplan pg_node_attr(read_write_ignore)
Cardinality total_table_pages
Definition: pathnodes.h:478
void *join_search_private pg_node_attr(read_write_ignore)
Query * parse
Definition: pathnodes.h:202
List * rowMarks
Definition: pathnodes.h:371
Cardinality limit_tuples
Definition: pathnodes.h:483
List * query_pathkeys
Definition: pathnodes.h:385
Selectivity tuple_fraction
Definition: pathnodes.h:481
List * update_colnos
Definition: pathnodes.h:464
bool placeholdersFrozen
Definition: pathnodes.h:502
List *upper_rels[UPPERREL_FINAL+1] pg_node_attr(read_write_ignore)
int placeholder_array_size pg_node_attr(read_write_ignore)
List * join_info_list
Definition: pathnodes.h:340
struct PlaceHolderInfo **placeholder_array pg_node_attr(read_write_ignore, array_size(placeholder_array_size))
bool hasPseudoConstantQuals
Definition: pathnodes.h:498
Relids all_baserels
Definition: pathnodes.h:255
struct PathTarget *upper_targets[UPPERREL_FINAL+1] pg_node_attr(read_write_ignore)
Relids all_result_relids
Definition: pathnodes.h:354
int join_cur_level
Definition: pathnodes.h:296
Relids leaf_result_relids
Definition: pathnodes.h:356
pg_node_attr(no_copy_equal, no_read) NodeTag type
Path * subpath
Definition: pathnodes.h:2151
Path * subpath
Definition: pathnodes.h:2139
Cost per_tuple
Definition: pathnodes.h:48
Cost startup
Definition: pathnodes.h:47
Cardinality numGroups
Definition: pathnodes.h:2316
List * baserestrictinfo
Definition: pathnodes.h:974
bool consider_param_startup
Definition: pathnodes.h:880
List * subplan_params
Definition: pathnodes.h:943
List * ppilist
Definition: pathnodes.h:894
bool useridiscurrent
Definition: pathnodes.h:957
uint32 amflags
Definition: pathnodes.h:947
List * joininfo
Definition: pathnodes.h:980
List * partition_qual
Definition: pathnodes.h:1016
Relids relids
Definition: pathnodes.h:866
struct PathTarget * reltarget
Definition: pathnodes.h:888
Index relid
Definition: pathnodes.h:913
List **nullable_partexprs pg_node_attr(read_write_ignore)
int32 *attr_widths pg_node_attr(read_write_ignore)
List * statlist
Definition: pathnodes.h:935
List **partexprs pg_node_attr(read_write_ignore)
struct PartitionBoundInfoData *boundinfo pg_node_attr(read_write_ignore)
struct FdwRoutine *fdwroutine pg_node_attr(read_write_ignore)
List * lateral_vars
Definition: pathnodes.h:929
Relids *attr_needed pg_node_attr(read_write_ignore)
List * unique_for_rels
Definition: pathnodes.h:966
void *fdw_private pg_node_attr(read_write_ignore)
Cardinality tuples
Definition: pathnodes.h:938
bool consider_parallel
Definition: pathnodes.h:882
Relids top_parent_relids
Definition: pathnodes.h:998
PartitionScheme part_scheme pg_node_attr(read_write_ignore)
struct RelOptInfo **part_rels pg_node_attr(read_write_ignore)
bool partbounds_merged
Definition: pathnodes.h:1014
BlockNumber pages
Definition: pathnodes.h:937
Relids lateral_relids
Definition: pathnodes.h:908
List * cheapest_parameterized_paths
Definition: pathnodes.h:899
List * pathlist
Definition: pathnodes.h:893
RelOptKind reloptkind
Definition: pathnodes.h:860
List * indexlist
Definition: pathnodes.h:933
struct RelOptInfo *parent pg_node_attr(read_write_ignore)
struct Path * cheapest_unique_path
Definition: pathnodes.h:898
Oid reltablespace
Definition: pathnodes.h:915
Relids lateral_referencers
Definition: pathnodes.h:931
struct Path * cheapest_startup_path
Definition: pathnodes.h:896
QualCost baserestrictcost
Definition: pathnodes.h:976
struct Path * cheapest_total_path
Definition: pathnodes.h:897
Oid userid
Definition: pathnodes.h:955
List * non_unique_for_rels
Definition: pathnodes.h:968
Bitmapset * eclass_indexes
Definition: pathnodes.h:941
Relids all_partrels
Definition: pathnodes.h:1030
struct RelOptInfo *top_parent pg_node_attr(read_write_ignore)
Relids direct_lateral_relids
Definition: pathnodes.h:906
bool has_eclass_joins
Definition: pathnodes.h:982
Oid serverid
Definition: pathnodes.h:953
bool consider_startup
Definition: pathnodes.h:878
Bitmapset * live_parts
Definition: pathnodes.h:1028
int rel_parallel_workers
Definition: pathnodes.h:945
bool consider_partitionwise_join
Definition: pathnodes.h:988
List * partial_pathlist
Definition: pathnodes.h:895
pg_node_attr(no_copy_equal, no_read) NodeTag type
PlannerInfo * subroot
Definition: pathnodes.h:942
AttrNumber max_attr
Definition: pathnodes.h:921
Relids nulling_relids
Definition: pathnodes.h:927
Index baserestrict_min_security
Definition: pathnodes.h:978
double allvisfrac
Definition: pathnodes.h:939
Cardinality rows
Definition: pathnodes.h:872
AttrNumber min_attr
Definition: pathnodes.h:919
RTEKind rtekind
Definition: pathnodes.h:917
bool is_pushed_down
Definition: pathnodes.h:2520
Index security_level
Definition: pathnodes.h:2539
EquivalenceClass *left_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore)
Relids required_relids
Definition: pathnodes.h:2548
Selectivity norm_selec pg_node_attr(equal_ignore)
bool leakproof pg_node_attr(equal_ignore)
Oid hashjoinoperator pg_node_attr(equal_ignore)
pg_node_attr(no_read) NodeTag type
Selectivity outer_selec pg_node_attr(equal_ignore)
int rinfo_serial
Definition: pathnodes.h:2583
EquivalenceClass *parent_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore)
Selectivity left_mcvfreq pg_node_attr(equal_ignore)
Relids left_relids pg_node_attr(equal_ignore)
List *scansel_cache pg_node_attr(copy_as(NIL), equal_ignore, read_write_ignore)
VolatileFunctionStatus has_volatile pg_node_attr(equal_ignore)
bool can_join pg_node_attr(equal_ignore)
Selectivity right_bucketsize pg_node_attr(equal_ignore)
bool pseudoconstant pg_node_attr(equal_ignore)
Relids outer_relids
Definition: pathnodes.h:2551
EquivalenceClass *right_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore)
int num_base_rels pg_node_attr(equal_ignore)
EquivalenceMember *left_em pg_node_attr(copy_as_scalar, equal_ignore)
Selectivity right_mcvfreq pg_node_attr(equal_ignore)
Expr * clause
Definition: pathnodes.h:2517
List *mergeopfamilies pg_node_attr(equal_ignore)
bool outer_is_left pg_node_attr(equal_ignore)
QualCost eval_cost pg_node_attr(equal_ignore)
EquivalenceMember *right_em pg_node_attr(copy_as_scalar, equal_ignore)
Selectivity left_bucketsize pg_node_attr(equal_ignore)
Oid right_hasheqoperator pg_node_attr(equal_ignore)
Oid left_hasheqoperator pg_node_attr(equal_ignore)
Relids clause_relids pg_node_attr(equal_ignore)
Relids right_relids pg_node_attr(equal_ignore)
bool has_clone
Definition: pathnodes.h:2529
Expr *orclause pg_node_attr(equal_ignore)
Cardinality numGroups
Definition: pathnodes.h:2249
List * groupClause
Definition: pathnodes.h:2246
pg_node_attr(no_copy_equal, no_read) NodeTag type
List * gsets_data
Definition: pathnodes.h:2248
bool hashable
Definition: pathnodes.h:2250
List * gsets
Definition: pathnodes.h:2247
bool is_hashed
Definition: pathnodes.h:2251
pg_node_attr(no_copy_equal, no_read) NodeTag type
Selectivity outer_match_frac
Definition: pathnodes.h:3145
Selectivity match_count
Definition: pathnodes.h:3146
List * distinctList
Definition: pathnodes.h:2300
Cardinality numGroups
Definition: pathnodes.h:2303
int firstFlag
Definition: pathnodes.h:2302
Path * subpath
Definition: pathnodes.h:2297
SetOpCmd cmd
Definition: pathnodes.h:2298
Path path
Definition: pathnodes.h:2296
SetOpStrategy strategy
Definition: pathnodes.h:2299
AttrNumber flagColIdx
Definition: pathnodes.h:2301
Path path
Definition: pathnodes.h:2164
Path * subpath
Definition: pathnodes.h:2165
Relids commute_above_r
Definition: pathnodes.h:2838
Relids syn_lefthand
Definition: pathnodes.h:2833
Relids min_righthand
Definition: pathnodes.h:2832
List * semi_rhs_exprs
Definition: pathnodes.h:2845
Relids commute_above_l
Definition: pathnodes.h:2837
JoinType jointype
Definition: pathnodes.h:2835
Relids commute_below
Definition: pathnodes.h:2839
pg_node_attr(no_read) NodeTag type
Relids min_lefthand
Definition: pathnodes.h:2831
Relids syn_righthand
Definition: pathnodes.h:2834
List * semi_operators
Definition: pathnodes.h:2844
Bitmapset * keys
Definition: pathnodes.h:1278
pg_node_attr(no_copy_equal, no_read) NodeTag type
RelOptInfo *rel pg_node_attr(read_write_ignore)
List * tidquals
Definition: pathnodes.h:1802
Path path
Definition: pathnodes.h:1801
List * tidrangequals
Definition: pathnodes.h:1814
Path * subpath
Definition: pathnodes.h:1993
List * uniq_exprs
Definition: pathnodes.h:1996
UniquePathMethod umethod
Definition: pathnodes.h:1994
List * in_operators
Definition: pathnodes.h:1995
Definition: primnodes.h:223
Path * subpath
Definition: pathnodes.h:2284
WindowClause * winclause
Definition: pathnodes.h:2285
Definition: c.h:671