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