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