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