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 UniqueRelInfo, 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) given in UniqueRelInfo(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  * In the case of a foreign join, fdw_restrictinfo stores the RestrictInfos to
1826  * apply to the join, which are used by createplan.c to get pseudoconstant
1827  * clauses evaluated as one-time quals in a gating Result plan node.
1828  *
1829  * fdw_private stores FDW private data about the scan. While fdw_private is
1830  * not actually touched by the core code during normal operations, it's
1831  * generally a good idea to use a representation that can be dumped by
1832  * nodeToString(), so that you can examine the structure during debugging
1833  * with tools like pprint().
1834  */
1835 typedef struct ForeignPath
1836 {
1842 
1843 /*
1844  * CustomPath represents a table scan or a table join done by some out-of-core
1845  * extension.
1846  *
1847  * We provide a set of hooks here - which the provider must take care to set
1848  * up correctly - to allow extensions to supply their own methods of scanning
1849  * a relation or joing relations. For example, a provider might provide GPU
1850  * acceleration, a cache-based scan, or some other kind of logic we haven't
1851  * dreamed up yet.
1852  *
1853  * CustomPaths can be injected into the planning process for a base or join
1854  * relation by set_rel_pathlist_hook or set_join_pathlist_hook functions,
1855  * respectively.
1856  *
1857  * In the case of a table join, custom_restrictinfo stores the RestrictInfos
1858  * to apply to the join, which are used by createplan.c to get pseudoconstant
1859  * clauses evaluated as one-time quals in a gating Result plan node.
1860  *
1861  * Core code must avoid assuming that the CustomPath is only as large as
1862  * the structure declared here; providers are allowed to make it the first
1863  * element in a larger structure. (Since the planner never copies Paths,
1864  * this doesn't add any complication.) However, for consistency with the
1865  * FDW case, we provide a "custom_private" field in CustomPath; providers
1866  * may prefer to use that rather than define another struct type.
1867  */
1868 
1869 struct CustomPathMethods;
1870 
1871 typedef struct CustomPath
1872 {
1874  uint32 flags; /* mask of CUSTOMPATH_* flags, see
1875  * nodes/extensible.h */
1876  List *custom_paths; /* list of child Path nodes, if any */
1881 
1882 /*
1883  * AppendPath represents an Append plan, ie, successive execution of
1884  * several member plans.
1885  *
1886  * For partial Append, 'subpaths' contains non-partial subpaths followed by
1887  * partial subpaths.
1888  *
1889  * Note: it is possible for "subpaths" to contain only one, or even no,
1890  * elements. These cases are optimized during create_append_plan.
1891  * In particular, an AppendPath with no subpaths is a "dummy" path that
1892  * is created to represent the case that a relation is provably empty.
1893  * (This is a convenient representation because it means that when we build
1894  * an appendrel and find that all its children have been excluded, no extra
1895  * action is needed to recognize the relation as dummy.)
1896  */
1897 typedef struct AppendPath
1898 {
1900  List *subpaths; /* list of component Paths */
1901  /* Index of first partial path in subpaths; list_length(subpaths) if none */
1903  Cardinality limit_tuples; /* hard limit on output tuples, or -1 */
1905 
1906 #define IS_DUMMY_APPEND(p) \
1907  (IsA((p), AppendPath) && ((AppendPath *) (p))->subpaths == NIL)
1908 
1909 /*
1910  * A relation that's been proven empty will have one path that is dummy
1911  * (but might have projection paths on top). For historical reasons,
1912  * this is provided as a macro that wraps is_dummy_rel().
1913  */
1914 #define IS_DUMMY_REL(r) is_dummy_rel(r)
1915 extern bool is_dummy_rel(RelOptInfo *rel);
1916 
1917 /*
1918  * MergeAppendPath represents a MergeAppend plan, ie, the merging of sorted
1919  * results from several member plans to produce similarly-sorted output.
1920  */
1921 typedef struct MergeAppendPath
1922 {
1924  List *subpaths; /* list of component Paths */
1925  Cardinality limit_tuples; /* hard limit on output tuples, or -1 */
1927 
1928 /*
1929  * GroupResultPath represents use of a Result plan node to compute the
1930  * output of a degenerate GROUP BY case, wherein we know we should produce
1931  * exactly one row, which might then be filtered by a HAVING qual.
1932  *
1933  * Note that quals is a list of bare clauses, not RestrictInfos.
1934  */
1935 typedef struct GroupResultPath
1936 {
1940 
1941 /*
1942  * MaterialPath represents use of a Material plan node, i.e., caching of
1943  * the output of its subpath. This is used when the subpath is expensive
1944  * and needs to be scanned repeatedly, or when we need mark/restore ability
1945  * and the subpath doesn't have it.
1946  */
1947 typedef struct MaterialPath
1948 {
1952 
1953 /*
1954  * MemoizePath represents a Memoize plan node, i.e., a cache that caches
1955  * tuples from parameterized paths to save the underlying node from having to
1956  * be rescanned for parameter values which are already cached.
1957  */
1958 typedef struct MemoizePath
1959 {
1961  Path *subpath; /* outerpath to cache tuples from */
1962  List *hash_operators; /* OIDs of hash equality ops for cache keys */
1963  List *param_exprs; /* expressions that are cache keys */
1964  bool singlerow; /* true if the cache entry is to be marked as
1965  * complete after caching the first record. */
1966  bool binary_mode; /* true when cache key should be compared bit
1967  * by bit, false when using hash equality ops */
1968  Cardinality calls; /* expected number of rescans */
1969  uint32 est_entries; /* The maximum number of entries that the
1970  * planner expects will fit in the cache, or 0
1971  * if unknown */
1973 
1974 /*
1975  * UniquePath represents elimination of distinct rows from the output of
1976  * its subpath.
1977  *
1978  * This can represent significantly different plans: either hash-based or
1979  * sort-based implementation, or a no-op if the input path can be proven
1980  * distinct already. The decision is sufficiently localized that it's not
1981  * worth having separate Path node types. (Note: in the no-op case, we could
1982  * eliminate the UniquePath node entirely and just return the subpath; but
1983  * it's convenient to have a UniquePath in the path tree to signal upper-level
1984  * routines that the input is known distinct.)
1985  */
1986 typedef enum UniquePathMethod
1987 {
1988  UNIQUE_PATH_NOOP, /* input is known unique already */
1989  UNIQUE_PATH_HASH, /* use hashing */
1990  UNIQUE_PATH_SORT, /* use sorting */
1992 
1993 typedef struct UniquePath
1994 {
1998  List *in_operators; /* equality operators of the IN clause */
1999  List *uniq_exprs; /* expressions to be made unique */
2001 
2002 /*
2003  * GatherPath runs several copies of a plan in parallel and collects the
2004  * results. The parallel leader may also execute the plan, unless the
2005  * single_copy flag is set.
2006  */
2007 typedef struct GatherPath
2008 {
2010  Path *subpath; /* path for each worker */
2011  bool single_copy; /* don't execute path more than once */
2012  int num_workers; /* number of workers sought to help */
2014 
2015 /*
2016  * GatherMergePath runs several copies of a plan in parallel and collects
2017  * the results, preserving their common sort order.
2018  */
2019 typedef struct GatherMergePath
2020 {
2022  Path *subpath; /* path for each worker */
2023  int num_workers; /* number of workers sought to help */
2025 
2026 
2027 /*
2028  * All join-type paths share these fields.
2029  */
2030 
2031 typedef struct JoinPath
2032 {
2033  pg_node_attr(abstract)
2034 
2035  Path path;
2036 
2038 
2039  bool inner_unique; /* each outer tuple provably matches no more
2040  * than one inner tuple */
2041 
2042  Path *outerjoinpath; /* path for the outer side of the join */
2043  Path *innerjoinpath; /* path for the inner side of the join */
2044 
2045  List *joinrestrictinfo; /* RestrictInfos to apply to join */
2046 
2047  /*
2048  * See the notes for RelOptInfo and ParamPathInfo to understand why
2049  * joinrestrictinfo is needed in JoinPath, and can't be merged into the
2050  * parent RelOptInfo.
2051  */
2053 
2054 /*
2055  * A nested-loop path needs no special fields.
2056  */
2057 
2058 typedef struct NestPath
2059 {
2062 
2063 /*
2064  * A mergejoin path has these fields.
2065  *
2066  * Unlike other path types, a MergePath node doesn't represent just a single
2067  * run-time plan node: it can represent up to four. Aside from the MergeJoin
2068  * node itself, there can be a Sort node for the outer input, a Sort node
2069  * for the inner input, and/or a Material node for the inner input. We could
2070  * represent these nodes by separate path nodes, but considering how many
2071  * different merge paths are investigated during a complex join problem,
2072  * it seems better to avoid unnecessary palloc overhead.
2073  *
2074  * path_mergeclauses lists the clauses (in the form of RestrictInfos)
2075  * that will be used in the merge.
2076  *
2077  * Note that the mergeclauses are a subset of the parent relation's
2078  * restriction-clause list. Any join clauses that are not mergejoinable
2079  * appear only in the parent's restrict list, and must be checked by a
2080  * qpqual at execution time.
2081  *
2082  * outersortkeys (resp. innersortkeys) is NIL if the outer path
2083  * (resp. inner path) is already ordered appropriately for the
2084  * mergejoin. If it is not NIL then it is a PathKeys list describing
2085  * the ordering that must be created by an explicit Sort node.
2086  *
2087  * skip_mark_restore is true if the executor need not do mark/restore calls.
2088  * Mark/restore overhead is usually required, but can be skipped if we know
2089  * that the executor need find only one match per outer tuple, and that the
2090  * mergeclauses are sufficient to identify a match. In such cases the
2091  * executor can immediately advance the outer relation after processing a
2092  * match, and therefore it need never back up the inner relation.
2093  *
2094  * materialize_inner is true if a Material node should be placed atop the
2095  * inner input. This may appear with or without an inner Sort step.
2096  */
2097 
2098 typedef struct MergePath
2099 {
2101  List *path_mergeclauses; /* join clauses to be used for merge */
2102  List *outersortkeys; /* keys for explicit sort, if any */
2103  List *innersortkeys; /* keys for explicit sort, if any */
2104  bool skip_mark_restore; /* can executor skip mark/restore? */
2105  bool materialize_inner; /* add Materialize to inner? */
2107 
2108 /*
2109  * A hashjoin path has these fields.
2110  *
2111  * The remarks above for mergeclauses apply for hashclauses as well.
2112  *
2113  * Hashjoin does not care what order its inputs appear in, so we have
2114  * no need for sortkeys.
2115  */
2116 
2117 typedef struct HashPath
2118 {
2120  List *path_hashclauses; /* join clauses used for hashing */
2121  int num_batches; /* number of batches expected */
2122  Cardinality inner_rows_total; /* total inner rows expected */
2124 
2125 /*
2126  * ProjectionPath represents a projection (that is, targetlist computation)
2127  *
2128  * Nominally, this path node represents using a Result plan node to do a
2129  * projection step. However, if the input plan node supports projection,
2130  * we can just modify its output targetlist to do the required calculations
2131  * directly, and not need a Result. In some places in the planner we can just
2132  * jam the desired PathTarget into the input path node (and adjust its cost
2133  * accordingly), so we don't need a ProjectionPath. But in other places
2134  * it's necessary to not modify the input path node, so we need a separate
2135  * ProjectionPath node, which is marked dummy to indicate that we intend to
2136  * assign the work to the input plan node. The estimated cost for the
2137  * ProjectionPath node will account for whether a Result will be used or not.
2138  */
2139 typedef struct ProjectionPath
2140 {
2142  Path *subpath; /* path representing input source */
2143  bool dummypp; /* true if no separate Result is needed */
2145 
2146 /*
2147  * ProjectSetPath represents evaluation of a targetlist that includes
2148  * set-returning function(s), which will need to be implemented by a
2149  * ProjectSet plan node.
2150  */
2151 typedef struct ProjectSetPath
2152 {
2154  Path *subpath; /* path representing input source */
2156 
2157 /*
2158  * SortPath represents an explicit sort step
2159  *
2160  * The sort keys are, by definition, the same as path.pathkeys.
2161  *
2162  * Note: the Sort plan node cannot project, so path.pathtarget must be the
2163  * same as the input's pathtarget.
2164  */
2165 typedef struct SortPath
2166 {
2168  Path *subpath; /* path representing input source */
2170 
2171 /*
2172  * IncrementalSortPath represents an incremental sort step
2173  *
2174  * This is like a regular sort, except some leading key columns are assumed
2175  * to be ordered already.
2176  */
2177 typedef struct IncrementalSortPath
2178 {
2180  int nPresortedCols; /* number of presorted columns */
2182 
2183 /*
2184  * GroupPath represents grouping (of presorted input)
2185  *
2186  * groupClause represents the columns to be grouped on; the input path
2187  * must be at least that well sorted.
2188  *
2189  * We can also apply a qual to the grouped rows (equivalent of HAVING)
2190  */
2191 typedef struct GroupPath
2192 {
2194  Path *subpath; /* path representing input source */
2195  List *groupClause; /* a list of SortGroupClause's */
2196  List *qual; /* quals (HAVING quals), if any */
2198 
2199 /*
2200  * UpperUniquePath represents adjacent-duplicate removal (in presorted input)
2201  *
2202  * The columns to be compared are the first numkeys columns of the path's
2203  * pathkeys. The input is presumed already sorted that way.
2204  */
2205 typedef struct UpperUniquePath
2206 {
2208  Path *subpath; /* path representing input source */
2209  int numkeys; /* number of pathkey columns to compare */
2211 
2212 /*
2213  * AggPath represents generic computation of aggregate functions
2214  *
2215  * This may involve plain grouping (but not grouping sets), using either
2216  * sorted or hashed grouping; for the AGG_SORTED case, the input must be
2217  * appropriately presorted.
2218  */
2219 typedef struct AggPath
2220 {
2222  Path *subpath; /* path representing input source */
2223  AggStrategy aggstrategy; /* basic strategy, see nodes.h */
2224  AggSplit aggsplit; /* agg-splitting mode, see nodes.h */
2225  Cardinality numGroups; /* estimated number of groups in input */
2226  uint64 transitionSpace; /* for pass-by-ref transition data */
2227  List *groupClause; /* a list of SortGroupClause's */
2228  List *qual; /* quals (HAVING quals), if any */
2230 
2231 /*
2232  * Various annotations used for grouping sets in the planner.
2233  */
2234 
2235 typedef struct GroupingSetData
2236 {
2237  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
2238 
2239  NodeTag type;
2240  List *set; /* grouping set as list of sortgrouprefs */
2241  Cardinality numGroups; /* est. number of result groups */
2243 
2244 typedef struct RollupData
2245 {
2246  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
2247 
2248  NodeTag type;
2249  List *groupClause; /* applicable subset of parse->groupClause */
2250  List *gsets; /* lists of integer indexes into groupClause */
2251  List *gsets_data; /* list of GroupingSetData */
2252  Cardinality numGroups; /* est. number of result groups */
2253  bool hashable; /* can be hashed */
2254  bool is_hashed; /* to be implemented as a hashagg */
2256 
2257 /*
2258  * GroupingSetsPath represents a GROUPING SETS aggregation
2259  */
2260 
2261 typedef struct GroupingSetsPath
2262 {
2264  Path *subpath; /* path representing input source */
2265  AggStrategy aggstrategy; /* basic strategy */
2266  List *rollups; /* list of RollupData */
2267  List *qual; /* quals (HAVING quals), if any */
2268  uint64 transitionSpace; /* for pass-by-ref transition data */
2270 
2271 /*
2272  * MinMaxAggPath represents computation of MIN/MAX aggregates from indexes
2273  */
2274 typedef struct MinMaxAggPath
2275 {
2277  List *mmaggregates; /* list of MinMaxAggInfo */
2278  List *quals; /* HAVING quals, if any */
2280 
2281 /*
2282  * WindowAggPath represents generic computation of window functions
2283  */
2284 typedef struct WindowAggPath
2285 {
2287  Path *subpath; /* path representing input source */
2288  WindowClause *winclause; /* WindowClause we'll be using */
2289  List *qual; /* lower-level WindowAgg runconditions */
2290  bool topwindow; /* false for all apart from the WindowAgg
2291  * that's closest to the root of the plan */
2293 
2294 /*
2295  * SetOpPath represents a set-operation, that is INTERSECT or EXCEPT
2296  */
2297 typedef struct SetOpPath
2298 {
2300  Path *subpath; /* path representing input source */
2301  SetOpCmd cmd; /* what to do, see nodes.h */
2302  SetOpStrategy strategy; /* how to do it, see nodes.h */
2303  List *distinctList; /* SortGroupClauses identifying target cols */
2304  AttrNumber flagColIdx; /* where is the flag column, if any */
2305  int firstFlag; /* flag value for first input relation */
2306  Cardinality numGroups; /* estimated number of groups in input */
2308 
2309 /*
2310  * RecursiveUnionPath represents a recursive UNION node
2311  */
2312 typedef struct RecursiveUnionPath
2313 {
2315  Path *leftpath; /* paths representing input sources */
2317  List *distinctList; /* SortGroupClauses identifying target cols */
2318  int wtParam; /* ID of Param representing work table */
2319  Cardinality numGroups; /* estimated number of groups in input */
2321 
2322 /*
2323  * LockRowsPath represents acquiring row locks for SELECT FOR UPDATE/SHARE
2324  */
2325 typedef struct LockRowsPath
2326 {
2328  Path *subpath; /* path representing input source */
2329  List *rowMarks; /* a list of PlanRowMark's */
2330  int epqParam; /* ID of Param for EvalPlanQual re-eval */
2332 
2333 /*
2334  * ModifyTablePath represents performing INSERT/UPDATE/DELETE/MERGE
2335  *
2336  * We represent most things that will be in the ModifyTable plan node
2337  * literally, except we have a child Path not Plan. But analysis of the
2338  * OnConflictExpr is deferred to createplan.c, as is collection of FDW data.
2339  */
2340 typedef struct ModifyTablePath
2341 {
2343  Path *subpath; /* Path producing source data */
2344  CmdType operation; /* INSERT, UPDATE, DELETE, or MERGE */
2345  bool canSetTag; /* do we set the command tag/es_processed? */
2346  Index nominalRelation; /* Parent RT index for use of EXPLAIN */
2347  Index rootRelation; /* Root RT index, if partitioned/inherited */
2348  bool partColsUpdated; /* some part key in hierarchy updated? */
2349  List *resultRelations; /* integer list of RT indexes */
2350  List *updateColnosLists; /* per-target-table update_colnos lists */
2351  List *withCheckOptionLists; /* per-target-table WCO lists */
2352  List *returningLists; /* per-target-table RETURNING tlists */
2353  List *rowMarks; /* PlanRowMarks (non-locking only) */
2354  OnConflictExpr *onconflict; /* ON CONFLICT clause, or NULL */
2355  int epqParam; /* ID of Param for EvalPlanQual re-eval */
2356  List *mergeActionLists; /* per-target-table lists of actions for
2357  * MERGE */
2359 
2360 /*
2361  * LimitPath represents applying LIMIT/OFFSET restrictions
2362  */
2363 typedef struct LimitPath
2364 {
2366  Path *subpath; /* path representing input source */
2367  Node *limitOffset; /* OFFSET parameter, or NULL if none */
2368  Node *limitCount; /* COUNT parameter, or NULL if none */
2369  LimitOption limitOption; /* FETCH FIRST with ties or exact number */
2371 
2372 
2373 /*
2374  * Restriction clause info.
2375  *
2376  * We create one of these for each AND sub-clause of a restriction condition
2377  * (WHERE or JOIN/ON clause). Since the restriction clauses are logically
2378  * ANDed, we can use any one of them or any subset of them to filter out
2379  * tuples, without having to evaluate the rest. The RestrictInfo node itself
2380  * stores data used by the optimizer while choosing the best query plan.
2381  *
2382  * If a restriction clause references a single base relation, it will appear
2383  * in the baserestrictinfo list of the RelOptInfo for that base rel.
2384  *
2385  * If a restriction clause references more than one base+OJ relation, it will
2386  * appear in the joininfo list of every RelOptInfo that describes a strict
2387  * subset of the relations mentioned in the clause. The joininfo lists are
2388  * used to drive join tree building by selecting plausible join candidates.
2389  * The clause cannot actually be applied until we have built a join rel
2390  * containing all the relations it references, however.
2391  *
2392  * When we construct a join rel that includes all the relations referenced
2393  * in a multi-relation restriction clause, we place that clause into the
2394  * joinrestrictinfo lists of paths for the join rel, if neither left nor
2395  * right sub-path includes all relations referenced in the clause. The clause
2396  * will be applied at that join level, and will not propagate any further up
2397  * the join tree. (Note: the "predicate migration" code was once intended to
2398  * push restriction clauses up and down the plan tree based on evaluation
2399  * costs, but it's dead code and is unlikely to be resurrected in the
2400  * foreseeable future.)
2401  *
2402  * Note that in the presence of more than two rels, a multi-rel restriction
2403  * might reach different heights in the join tree depending on the join
2404  * sequence we use. So, these clauses cannot be associated directly with
2405  * the join RelOptInfo, but must be kept track of on a per-join-path basis.
2406  *
2407  * RestrictInfos that represent equivalence conditions (i.e., mergejoinable
2408  * equalities that are not outerjoin-delayed) are handled a bit differently.
2409  * Initially we attach them to the EquivalenceClasses that are derived from
2410  * them. When we construct a scan or join path, we look through all the
2411  * EquivalenceClasses and generate derived RestrictInfos representing the
2412  * minimal set of conditions that need to be checked for this particular scan
2413  * or join to enforce that all members of each EquivalenceClass are in fact
2414  * equal in all rows emitted by the scan or join.
2415  *
2416  * The clause_relids field lists the base plus outer-join RT indexes that
2417  * actually appear in the clause. required_relids lists the minimum set of
2418  * relids needed to evaluate the clause; while this is often equal to
2419  * clause_relids, it can be more. We will add relids to required_relids when
2420  * we need to force an outer join ON clause to be evaluated exactly at the
2421  * level of the outer join, which is true except when it is a "degenerate"
2422  * condition that references only Vars from the nullable side of the join.
2423  *
2424  * RestrictInfo nodes contain a flag to indicate whether a qual has been
2425  * pushed down to a lower level than its original syntactic placement in the
2426  * join tree would suggest. If an outer join prevents us from pushing a qual
2427  * down to its "natural" semantic level (the level associated with just the
2428  * base rels used in the qual) then we mark the qual with a "required_relids"
2429  * value including more than just the base rels it actually uses. By
2430  * pretending that the qual references all the rels required to form the outer
2431  * join, we prevent it from being evaluated below the outer join's joinrel.
2432  * When we do form the outer join's joinrel, we still need to distinguish
2433  * those quals that are actually in that join's JOIN/ON condition from those
2434  * that appeared elsewhere in the tree and were pushed down to the join rel
2435  * because they used no other rels. That's what the is_pushed_down flag is
2436  * for; it tells us that a qual is not an OUTER JOIN qual for the set of base
2437  * rels listed in required_relids. A clause that originally came from WHERE
2438  * or an INNER JOIN condition will *always* have its is_pushed_down flag set.
2439  * It's possible for an OUTER JOIN clause to be marked is_pushed_down too,
2440  * if we decide that it can be pushed down into the nullable side of the join.
2441  * In that case it acts as a plain filter qual for wherever it gets evaluated.
2442  * (In short, is_pushed_down is only false for non-degenerate outer join
2443  * conditions. Possibly we should rename it to reflect that meaning? But
2444  * see also the comments for RINFO_IS_PUSHED_DOWN, below.)
2445  *
2446  * There is also an incompatible_relids field, which is a set of outer-join
2447  * relids above which we cannot evaluate the clause (because they might null
2448  * Vars it uses that should not be nulled yet). In principle this could be
2449  * filled in any RestrictInfo as the set of OJ relids that appear above the
2450  * clause and null Vars that it uses. In practice we only bother to populate
2451  * it for "clone" clauses, as it's currently only needed to prevent multiple
2452  * clones of the same clause from being accepted for evaluation at the same
2453  * join level.
2454  *
2455  * There is also an outer_relids field, which is NULL except for outer join
2456  * clauses; for those, it is the set of relids on the outer side of the
2457  * clause's outer join. (These are rels that the clause cannot be applied to
2458  * in parameterized scans, since pushing it into the join's outer side would
2459  * lead to wrong answers.)
2460  *
2461  * To handle security-barrier conditions efficiently, we mark RestrictInfo
2462  * nodes with a security_level field, in which higher values identify clauses
2463  * coming from less-trusted sources. The exact semantics are that a clause
2464  * cannot be evaluated before another clause with a lower security_level value
2465  * unless the first clause is leakproof. As with outer-join clauses, this
2466  * creates a reason for clauses to sometimes need to be evaluated higher in
2467  * the join tree than their contents would suggest; and even at a single plan
2468  * node, this rule constrains the order of application of clauses.
2469  *
2470  * In general, the referenced clause might be arbitrarily complex. The
2471  * kinds of clauses we can handle as indexscan quals, mergejoin clauses,
2472  * or hashjoin clauses are limited (e.g., no volatile functions). The code
2473  * for each kind of path is responsible for identifying the restrict clauses
2474  * it can use and ignoring the rest. Clauses not implemented by an indexscan,
2475  * mergejoin, or hashjoin will be placed in the plan qual or joinqual field
2476  * of the finished Plan node, where they will be enforced by general-purpose
2477  * qual-expression-evaluation code. (But we are still entitled to count
2478  * their selectivity when estimating the result tuple count, if we
2479  * can guess what it is...)
2480  *
2481  * When the referenced clause is an OR clause, we generate a modified copy
2482  * in which additional RestrictInfo nodes are inserted below the top-level
2483  * OR/AND structure. This is a convenience for OR indexscan processing:
2484  * indexquals taken from either the top level or an OR subclause will have
2485  * associated RestrictInfo nodes.
2486  *
2487  * The can_join flag is set true if the clause looks potentially useful as
2488  * a merge or hash join clause, that is if it is a binary opclause with
2489  * nonoverlapping sets of relids referenced in the left and right sides.
2490  * (Whether the operator is actually merge or hash joinable isn't checked,
2491  * however.)
2492  *
2493  * The pseudoconstant flag is set true if the clause contains no Vars of
2494  * the current query level and no volatile functions. Such a clause can be
2495  * pulled out and used as a one-time qual in a gating Result node. We keep
2496  * pseudoconstant clauses in the same lists as other RestrictInfos so that
2497  * the regular clause-pushing machinery can assign them to the correct join
2498  * level, but they need to be treated specially for cost and selectivity
2499  * estimates. Note that a pseudoconstant clause can never be an indexqual
2500  * or merge or hash join clause, so it's of no interest to large parts of
2501  * the planner.
2502  *
2503  * When we generate multiple versions of a clause so as to have versions
2504  * that will work after commuting some left joins per outer join identity 3,
2505  * we mark the one with the fewest nullingrels bits with has_clone = true,
2506  * and the rest with is_clone = true. This allows proper filtering of
2507  * these redundant clauses, so that we apply only one version of them.
2508  *
2509  * When join clauses are generated from EquivalenceClasses, there may be
2510  * several equally valid ways to enforce join equivalence, of which we need
2511  * apply only one. We mark clauses of this kind by setting parent_ec to
2512  * point to the generating EquivalenceClass. Multiple clauses with the same
2513  * parent_ec in the same join are redundant.
2514  *
2515  * Most fields are ignored for equality, since they may not be set yet, and
2516  * should be derivable from the clause anyway.
2517  *
2518  * parent_ec, left_ec, right_ec are not printed, lest it lead to infinite
2519  * recursion in plan tree dump.
2520  */
2521 
2522 typedef struct RestrictInfo
2523 {
2524  pg_node_attr(no_read, no_query_jumble)
2525 
2526  NodeTag type;
2527 
2528  /* the represented clause of WHERE or JOIN */
2530 
2531  /* true if clause was pushed down in level */
2533 
2534  /* see comment above */
2535  bool can_join pg_node_attr(equal_ignore);
2536 
2537  /* see comment above */
2538  bool pseudoconstant pg_node_attr(equal_ignore);
2539 
2540  /* see comment above */
2542  bool is_clone;
2543 
2544  /* true if known to contain no leaked Vars */
2545  bool leakproof pg_node_attr(equal_ignore);
2546 
2547  /* indicates if clause contains any volatile functions */
2548  VolatileFunctionStatus has_volatile pg_node_attr(equal_ignore);
2549 
2550  /* see comment above */
2552 
2553  /* number of base rels in clause_relids */
2554  int num_base_rels pg_node_attr(equal_ignore);
2555 
2556  /* The relids (varnos+varnullingrels) actually referenced in the clause: */
2557  Relids clause_relids pg_node_attr(equal_ignore);
2558 
2559  /* The set of relids required to evaluate the clause: */
2561 
2562  /* Relids above which we cannot evaluate the clause (see comment above) */
2564 
2565  /* If an outer-join clause, the outer-side relations, else NULL: */
2567 
2568  /*
2569  * Relids in the left/right side of the clause. These fields are set for
2570  * any binary opclause.
2571  */
2572  Relids left_relids pg_node_attr(equal_ignore);
2573  Relids right_relids pg_node_attr(equal_ignore);
2574 
2575  /*
2576  * Modified clause with RestrictInfos. This field is NULL unless clause
2577  * is an OR clause.
2578  */
2579  Expr *orclause pg_node_attr(equal_ignore);
2580 
2581  /*----------
2582  * Serial number of this RestrictInfo. This is unique within the current
2583  * PlannerInfo context, with a few critical exceptions:
2584  * 1. When we generate multiple clones of the same qual condition to
2585  * cope with outer join identity 3, all the clones get the same serial
2586  * number. This reflects that we only want to apply one of them in any
2587  * given plan.
2588  * 2. If we manufacture a commuted version of a qual to use as an index
2589  * condition, it copies the original's rinfo_serial, since it is in
2590  * practice the same condition.
2591  * 3. RestrictInfos made for a child relation copy their parent's
2592  * rinfo_serial. Likewise, when an EquivalenceClass makes a derived
2593  * equality clause for a child relation, it copies the rinfo_serial of
2594  * the matching equality clause for the parent. This allows detection
2595  * of redundant pushed-down equality clauses.
2596  *----------
2597  */
2599 
2600  /*
2601  * Generating EquivalenceClass. This field is NULL unless clause is
2602  * potentially redundant.
2603  */
2604  EquivalenceClass *parent_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
2605 
2606  /*
2607  * cache space for cost and selectivity
2608  */
2609 
2610  /* eval cost of clause; -1 if not yet set */
2611  QualCost eval_cost pg_node_attr(equal_ignore);
2612 
2613  /* selectivity for "normal" (JOIN_INNER) semantics; -1 if not yet set */
2614  Selectivity norm_selec pg_node_attr(equal_ignore);
2615  /* selectivity for outer join semantics; -1 if not yet set */
2616  Selectivity outer_selec pg_node_attr(equal_ignore);
2617 
2618  /*
2619  * opfamilies containing clause operator; valid if clause is
2620  * mergejoinable, else NIL
2621  */
2622  List *mergeopfamilies pg_node_attr(equal_ignore);
2623 
2624  /*
2625  * cache space for mergeclause processing; NULL if not yet set
2626  */
2627 
2628  /* EquivalenceClass containing lefthand */
2629  EquivalenceClass *left_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
2630  /* EquivalenceClass containing righthand */
2631  EquivalenceClass *right_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore);
2632  /* EquivalenceMember for lefthand */
2633  EquivalenceMember *left_em pg_node_attr(copy_as_scalar, equal_ignore);
2634  /* EquivalenceMember for righthand */
2635  EquivalenceMember *right_em pg_node_attr(copy_as_scalar, equal_ignore);
2636 
2637  /*
2638  * List of MergeScanSelCache structs. Those aren't Nodes, so hard to
2639  * copy; instead replace with NIL. That has the effect that copying will
2640  * just reset the cache. Likewise, can't compare or print them.
2641  */
2642  List *scansel_cache pg_node_attr(copy_as(NIL), equal_ignore, read_write_ignore);
2643 
2644  /*
2645  * transient workspace for use while considering a specific join path; T =
2646  * outer var on left, F = on right
2647  */
2648  bool outer_is_left pg_node_attr(equal_ignore);
2649 
2650  /*
2651  * copy of clause operator; valid if clause is hashjoinable, else
2652  * InvalidOid
2653  */
2654  Oid hashjoinoperator pg_node_attr(equal_ignore);
2655 
2656  /*
2657  * cache space for hashclause processing; -1 if not yet set
2658  */
2659  /* avg bucketsize of left side */
2660  Selectivity left_bucketsize pg_node_attr(equal_ignore);
2661  /* avg bucketsize of right side */
2662  Selectivity right_bucketsize pg_node_attr(equal_ignore);
2663  /* left side's most common val's freq */
2664  Selectivity left_mcvfreq pg_node_attr(equal_ignore);
2665  /* right side's most common val's freq */
2666  Selectivity right_mcvfreq pg_node_attr(equal_ignore);
2667 
2668  /* hash equality operators used for memoize nodes, else InvalidOid */
2669  Oid left_hasheqoperator pg_node_attr(equal_ignore);
2670  Oid right_hasheqoperator pg_node_attr(equal_ignore);
2672 
2673 /*
2674  * This macro embodies the correct way to test whether a RestrictInfo is
2675  * "pushed down" to a given outer join, that is, should be treated as a filter
2676  * clause rather than a join clause at that outer join. This is certainly so
2677  * if is_pushed_down is true; but examining that is not sufficient anymore,
2678  * because outer-join clauses will get pushed down to lower outer joins when
2679  * we generate a path for the lower outer join that is parameterized by the
2680  * LHS of the upper one. We can detect such a clause by noting that its
2681  * required_relids exceed the scope of the join.
2682  */
2683 #define RINFO_IS_PUSHED_DOWN(rinfo, joinrelids) \
2684  ((rinfo)->is_pushed_down || \
2685  !bms_is_subset((rinfo)->required_relids, joinrelids))
2686 
2687 /*
2688  * Since mergejoinscansel() is a relatively expensive function, and would
2689  * otherwise be invoked many times while planning a large join tree,
2690  * we go out of our way to cache its results. Each mergejoinable
2691  * RestrictInfo carries a list of the specific sort orderings that have
2692  * been considered for use with it, and the resulting selectivities.
2693  */
2694 typedef struct MergeScanSelCache
2695 {
2696  /* Ordering details (cache lookup key) */
2697  Oid opfamily; /* btree opfamily defining the ordering */
2698  Oid collation; /* collation for the ordering */
2699  int strategy; /* sort direction (ASC or DESC) */
2700  bool nulls_first; /* do NULLs come before normal values? */
2701  /* Results */
2702  Selectivity leftstartsel; /* first-join fraction for clause left side */
2703  Selectivity leftendsel; /* last-join fraction for clause left side */
2704  Selectivity rightstartsel; /* first-join fraction for clause right side */
2705  Selectivity rightendsel; /* last-join fraction for clause right side */
2707 
2708 /*
2709  * Placeholder node for an expression to be evaluated below the top level
2710  * of a plan tree. This is used during planning to represent the contained
2711  * expression. At the end of the planning process it is replaced by either
2712  * the contained expression or a Var referring to a lower-level evaluation of
2713  * the contained expression. Generally the evaluation occurs below an outer
2714  * join, and Var references above the outer join might thereby yield NULL
2715  * instead of the expression value.
2716  *
2717  * phrels and phlevelsup correspond to the varno/varlevelsup fields of a
2718  * plain Var, except that phrels has to be a relid set since the evaluation
2719  * level of a PlaceHolderVar might be a join rather than a base relation.
2720  * Likewise, phnullingrels corresponds to varnullingrels.
2721  *
2722  * Although the planner treats this as an expression node type, it is not
2723  * recognized by the parser or executor, so we declare it here rather than
2724  * in primnodes.h.
2725  *
2726  * We intentionally do not compare phexpr. Two PlaceHolderVars with the
2727  * same ID and levelsup should be considered equal even if the contained
2728  * expressions have managed to mutate to different states. This will
2729  * happen during final plan construction when there are nested PHVs, since
2730  * the inner PHV will get replaced by a Param in some copies of the outer
2731  * PHV. Another way in which it can happen is that initplan sublinks
2732  * could get replaced by differently-numbered Params when sublink folding
2733  * is done. (The end result of such a situation would be some
2734  * unreferenced initplans, which is annoying but not really a problem.)
2735  * On the same reasoning, there is no need to examine phrels. But we do
2736  * need to compare phnullingrels, as that represents effects that are
2737  * external to the original value of the PHV.
2738  */
2739 
2740 typedef struct PlaceHolderVar
2741 {
2742  pg_node_attr(no_query_jumble)
2743 
2744  Expr xpr;
2745 
2746  /* the represented expression */
2747  Expr *phexpr pg_node_attr(equal_ignore);
2748 
2749  /* base+OJ relids syntactically within expr src */
2750  Relids phrels pg_node_attr(equal_ignore);
2751 
2752  /* RT indexes of outer joins that can null PHV's value */
2754 
2755  /* ID for PHV (unique within planner run) */
2757 
2758  /* > 0 if PHV belongs to outer query */
2761 
2762 /*
2763  * "Special join" info.
2764  *
2765  * One-sided outer joins constrain the order of joining partially but not
2766  * completely. We flatten such joins into the planner's top-level list of
2767  * relations to join, but record information about each outer join in a
2768  * SpecialJoinInfo struct. These structs are kept in the PlannerInfo node's
2769  * join_info_list.
2770  *
2771  * Similarly, semijoins and antijoins created by flattening IN (subselect)
2772  * and EXISTS(subselect) clauses create partial constraints on join order.
2773  * These are likewise recorded in SpecialJoinInfo structs.
2774  *
2775  * We make SpecialJoinInfos for FULL JOINs even though there is no flexibility
2776  * of planning for them, because this simplifies make_join_rel()'s API.
2777  *
2778  * min_lefthand and min_righthand are the sets of base+OJ relids that must be
2779  * available on each side when performing the special join.
2780  * It is not valid for either min_lefthand or min_righthand to be empty sets;
2781  * if they were, this would break the logic that enforces join order.
2782  *
2783  * syn_lefthand and syn_righthand are the sets of base+OJ relids that are
2784  * syntactically below this special join. (These are needed to help compute
2785  * min_lefthand and min_righthand for higher joins.)
2786  *
2787  * jointype is never JOIN_RIGHT; a RIGHT JOIN is handled by switching
2788  * the inputs to make it a LEFT JOIN. It's never JOIN_RIGHT_ANTI either.
2789  * So the allowed values of jointype in a join_info_list member are only
2790  * LEFT, FULL, SEMI, or ANTI.
2791  *
2792  * ojrelid is the RT index of the join RTE representing this outer join,
2793  * if there is one. It is zero when jointype is INNER or SEMI, and can be
2794  * zero for jointype ANTI (if the join was transformed from a SEMI join).
2795  * One use for this field is that when constructing the output targetlist of a
2796  * join relation that implements this OJ, we add ojrelid to the varnullingrels
2797  * and phnullingrels fields of nullable (RHS) output columns, so that the
2798  * output Vars and PlaceHolderVars correctly reflect the nulling that has
2799  * potentially happened to them.
2800  *
2801  * commute_above_l is filled with the relids of syntactically-higher outer
2802  * joins that have been found to commute with this one per outer join identity
2803  * 3 (see optimizer/README), when this join is in the LHS of the upper join
2804  * (so, this is the lower join in the first form of the identity).
2805  *
2806  * commute_above_r is filled with the relids of syntactically-higher outer
2807  * joins that have been found to commute with this one per outer join identity
2808  * 3, when this join is in the RHS of the upper join (so, this is the lower
2809  * join in the second form of the identity).
2810  *
2811  * commute_below_l is filled with the relids of syntactically-lower outer
2812  * joins that have been found to commute with this one per outer join identity
2813  * 3 and are in the LHS of this join (so, this is the upper join in the first
2814  * form of the identity).
2815  *
2816  * commute_below_r is filled with the relids of syntactically-lower outer
2817  * joins that have been found to commute with this one per outer join identity
2818  * 3 and are in the RHS of this join (so, this is the upper join in the second
2819  * form of the identity).
2820  *
2821  * lhs_strict is true if the special join's condition cannot succeed when the
2822  * LHS variables are all NULL (this means that an outer join can commute with
2823  * upper-level outer joins even if it appears in their RHS). We don't bother
2824  * to set lhs_strict for FULL JOINs, however.
2825  *
2826  * For a semijoin, we also extract the join operators and their RHS arguments
2827  * and set semi_operators, semi_rhs_exprs, semi_can_btree, and semi_can_hash.
2828  * This is done in support of possibly unique-ifying the RHS, so we don't
2829  * bother unless at least one of semi_can_btree and semi_can_hash can be set
2830  * true. (You might expect that this information would be computed during
2831  * join planning; but it's helpful to have it available during planning of
2832  * parameterized table scans, so we store it in the SpecialJoinInfo structs.)
2833  *
2834  * For purposes of join selectivity estimation, we create transient
2835  * SpecialJoinInfo structures for regular inner joins; so it is possible
2836  * to have jointype == JOIN_INNER in such a structure, even though this is
2837  * not allowed within join_info_list. We also create transient
2838  * SpecialJoinInfos with jointype == JOIN_INNER for outer joins, since for
2839  * cost estimation purposes it is sometimes useful to know the join size under
2840  * plain innerjoin semantics. Note that lhs_strict and the semi_xxx fields
2841  * are not set meaningfully within such structs.
2842  */
2843 #ifndef HAVE_SPECIALJOININFO_TYPEDEF
2844 typedef struct SpecialJoinInfo SpecialJoinInfo;
2845 #define HAVE_SPECIALJOININFO_TYPEDEF 1
2846 #endif
2847 
2849 {
2850  pg_node_attr(no_read, no_query_jumble)
2851 
2852  NodeTag type;
2853  Relids min_lefthand; /* base+OJ relids in minimum LHS for join */
2854  Relids min_righthand; /* base+OJ relids in minimum RHS for join */
2855  Relids syn_lefthand; /* base+OJ relids syntactically within LHS */
2856  Relids syn_righthand; /* base+OJ relids syntactically within RHS */
2857  JoinType jointype; /* always INNER, LEFT, FULL, SEMI, or ANTI */
2858  Index ojrelid; /* outer join's RT index; 0 if none */
2859  Relids commute_above_l; /* commuting OJs above this one, if LHS */
2860  Relids commute_above_r; /* commuting OJs above this one, if RHS */
2861  Relids commute_below_l; /* commuting OJs in this one's LHS */
2862  Relids commute_below_r; /* commuting OJs in this one's RHS */
2863  bool lhs_strict; /* joinclause is strict for some LHS rel */
2864  /* Remaining fields are set only for JOIN_SEMI jointype: */
2865  bool semi_can_btree; /* true if semi_operators are all btree */
2866  bool semi_can_hash; /* true if semi_operators are all hash */
2867  List *semi_operators; /* OIDs of equality join operators */
2868  List *semi_rhs_exprs; /* righthand-side expressions of these ops */
2869 };
2870 
2871 /*
2872  * Transient outer-join clause info.
2873  *
2874  * We set aside every outer join ON clause that looks mergejoinable,
2875  * and process it specially at the end of qual distribution.
2876  */
2877 typedef struct OuterJoinClauseInfo
2878 {
2879  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
2880 
2881  NodeTag type;
2882  RestrictInfo *rinfo; /* a mergejoinable outer-join clause */
2883  SpecialJoinInfo *sjinfo; /* the outer join's SpecialJoinInfo */
2885 
2886 /*
2887  * Append-relation info.
2888  *
2889  * When we expand an inheritable table or a UNION-ALL subselect into an
2890  * "append relation" (essentially, a list of child RTEs), we build an
2891  * AppendRelInfo for each child RTE. The list of AppendRelInfos indicates
2892  * which child RTEs must be included when expanding the parent, and each node
2893  * carries information needed to translate between columns of the parent and
2894  * columns of the child.
2895  *
2896  * These structs are kept in the PlannerInfo node's append_rel_list, with
2897  * append_rel_array[] providing a convenient lookup method for the struct
2898  * associated with a particular child relid (there can be only one, though
2899  * parent rels may have many entries in append_rel_list).
2900  *
2901  * Note: after completion of the planner prep phase, any given RTE is an
2902  * append parent having entries in append_rel_list if and only if its
2903  * "inh" flag is set. We clear "inh" for plain tables that turn out not
2904  * to have inheritance children, and (in an abuse of the original meaning
2905  * of the flag) we set "inh" for subquery RTEs that turn out to be
2906  * flattenable UNION ALL queries. This lets us avoid useless searches
2907  * of append_rel_list.
2908  *
2909  * Note: the data structure assumes that append-rel members are single
2910  * baserels. This is OK for inheritance, but it prevents us from pulling
2911  * up a UNION ALL member subquery if it contains a join. While that could
2912  * be fixed with a more complex data structure, at present there's not much
2913  * point because no improvement in the plan could result.
2914  */
2915 
2916 typedef struct AppendRelInfo
2917 {
2918  pg_node_attr(no_query_jumble)
2919 
2920  NodeTag type;
2921 
2922  /*
2923  * These fields uniquely identify this append relationship. There can be
2924  * (in fact, always should be) multiple AppendRelInfos for the same
2925  * parent_relid, but never more than one per child_relid, since a given
2926  * RTE cannot be a child of more than one append parent.
2927  */
2928  Index parent_relid; /* RT index of append parent rel */
2929  Index child_relid; /* RT index of append child rel */
2930 
2931  /*
2932  * For an inheritance appendrel, the parent and child are both regular
2933  * relations, and we store their rowtype OIDs here for use in translating
2934  * whole-row Vars. For a UNION-ALL appendrel, the parent and child are
2935  * both subqueries with no named rowtype, and we store InvalidOid here.
2936  */
2937  Oid parent_reltype; /* OID of parent's composite type */
2938  Oid child_reltype; /* OID of child's composite type */
2939 
2940  /*
2941  * The N'th element of this list is a Var or expression representing the
2942  * child column corresponding to the N'th column of the parent. This is
2943  * used to translate Vars referencing the parent rel into references to
2944  * the child. A list element is NULL if it corresponds to a dropped
2945  * column of the parent (this is only possible for inheritance cases, not
2946  * UNION ALL). The list elements are always simple Vars for inheritance
2947  * cases, but can be arbitrary expressions in UNION ALL cases.
2948  *
2949  * Notice we only store entries for user columns (attno > 0). Whole-row
2950  * Vars are special-cased, and system columns (attno < 0) need no special
2951  * translation since their attnos are the same for all tables.
2952  *
2953  * Caution: the Vars have varlevelsup = 0. Be careful to adjust as needed
2954  * when copying into a subquery.
2955  */
2956  List *translated_vars; /* Expressions in the child's Vars */
2957 
2958  /*
2959  * This array simplifies translations in the reverse direction, from
2960  * child's column numbers to parent's. The entry at [ccolno - 1] is the
2961  * 1-based parent column number for child column ccolno, or zero if that
2962  * child column is dropped or doesn't exist in the parent.
2963  */
2964  int num_child_cols; /* length of array */
2965  AttrNumber *parent_colnos pg_node_attr(array_size(num_child_cols));
2966 
2967  /*
2968  * We store the parent table's OID here for inheritance, or InvalidOid for
2969  * UNION ALL. This is only needed to help in generating error messages if
2970  * an attempt is made to reference a dropped parent column.
2971  */
2972  Oid parent_reloid; /* OID of parent relation */
2974 
2975 /*
2976  * Information about a row-identity "resjunk" column in UPDATE/DELETE/MERGE.
2977  *
2978  * In partitioned UPDATE/DELETE/MERGE it's important for child partitions to
2979  * share row-identity columns whenever possible, so as not to chew up too many
2980  * targetlist columns. We use these structs to track which identity columns
2981  * have been requested. In the finished plan, each of these will give rise
2982  * to one resjunk entry in the targetlist of the ModifyTable's subplan node.
2983  *
2984  * All the Vars stored in RowIdentityVarInfos must have varno ROWID_VAR, for
2985  * convenience of detecting duplicate requests. We'll replace that, in the
2986  * final plan, with the varno of the generating rel.
2987  *
2988  * Outside this list, a Var with varno ROWID_VAR and varattno k is a reference
2989  * to the k-th element of the row_identity_vars list (k counting from 1).
2990  * We add such a reference to root->processed_tlist when creating the entry,
2991  * and it propagates into the plan tree from there.
2992  */
2993 typedef struct RowIdentityVarInfo
2994 {
2995  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
2996 
2997  NodeTag type;
2998 
2999  Var *rowidvar; /* Var to be evaluated (but varno=ROWID_VAR) */
3000  int32 rowidwidth; /* estimated average width */
3001  char *rowidname; /* name of the resjunk column */
3002  Relids rowidrels; /* RTE indexes of target rels using this */
3004 
3005 /*
3006  * For each distinct placeholder expression generated during planning, we
3007  * store a PlaceHolderInfo node in the PlannerInfo node's placeholder_list.
3008  * This stores info that is needed centrally rather than in each copy of the
3009  * PlaceHolderVar. The phid fields identify which PlaceHolderInfo goes with
3010  * each PlaceHolderVar. Note that phid is unique throughout a planner run,
3011  * not just within a query level --- this is so that we need not reassign ID's
3012  * when pulling a subquery into its parent.
3013  *
3014  * The idea is to evaluate the expression at (only) the ph_eval_at join level,
3015  * then allow it to bubble up like a Var until the ph_needed join level.
3016  * ph_needed has the same definition as attr_needed for a regular Var.
3017  *
3018  * The PlaceHolderVar's expression might contain LATERAL references to vars
3019  * coming from outside its syntactic scope. If so, those rels are *not*
3020  * included in ph_eval_at, but they are recorded in ph_lateral.
3021  *
3022  * Notice that when ph_eval_at is a join rather than a single baserel, the
3023  * PlaceHolderInfo may create constraints on join order: the ph_eval_at join
3024  * has to be formed below any outer joins that should null the PlaceHolderVar.
3025  *
3026  * We create a PlaceHolderInfo only after determining that the PlaceHolderVar
3027  * is actually referenced in the plan tree, so that unreferenced placeholders
3028  * don't result in unnecessary constraints on join order.
3029  */
3030 
3031 typedef struct PlaceHolderInfo
3032 {
3033  pg_node_attr(no_read, no_query_jumble)
3034 
3035  NodeTag type;
3036 
3037  /* ID for PH (unique within planner run) */
3039 
3040  /*
3041  * copy of PlaceHolderVar tree (should be redundant for comparison, could
3042  * be ignored)
3043  */
3045 
3046  /* lowest level we can evaluate value at */
3048 
3049  /* relids of contained lateral refs, if any */
3051 
3052  /* highest level the value is needed at */
3054 
3055  /* estimated attribute width */
3058 
3059 /*
3060  * This struct describes one potentially index-optimizable MIN/MAX aggregate
3061  * function. MinMaxAggPath contains a list of these, and if we accept that
3062  * path, the list is stored into root->minmax_aggs for use during setrefs.c.
3063  */
3064 typedef struct MinMaxAggInfo
3065 {
3066  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
3067 
3068  NodeTag type;
3069 
3070  /* pg_proc Oid of the aggregate */
3072 
3073  /* Oid of its sort operator */
3075 
3076  /* expression we are aggregating on */
3078 
3079  /*
3080  * modified "root" for planning the subquery; not printed, too large, not
3081  * interesting enough
3082  */
3083  PlannerInfo *subroot pg_node_attr(read_write_ignore);
3084 
3085  /* access path for subquery */
3087 
3088  /* estimated cost to fetch first row */
3090 
3091  /* param for subplan's output */
3094 
3095 /*
3096  * At runtime, PARAM_EXEC slots are used to pass values around from one plan
3097  * node to another. They can be used to pass values down into subqueries (for
3098  * outer references in subqueries), or up out of subqueries (for the results
3099  * of a subplan), or from a NestLoop plan node into its inner relation (when
3100  * the inner scan is parameterized with values from the outer relation).
3101  * The planner is responsible for assigning nonconflicting PARAM_EXEC IDs to
3102  * the PARAM_EXEC Params it generates.
3103  *
3104  * Outer references are managed via root->plan_params, which is a list of
3105  * PlannerParamItems. While planning a subquery, each parent query level's
3106  * plan_params contains the values required from it by the current subquery.
3107  * During create_plan(), we use plan_params to track values that must be
3108  * passed from outer to inner sides of NestLoop plan nodes.
3109  *
3110  * The item a PlannerParamItem represents can be one of three kinds:
3111  *
3112  * A Var: the slot represents a variable of this level that must be passed
3113  * down because subqueries have outer references to it, or must be passed
3114  * from a NestLoop node to its inner scan. The varlevelsup value in the Var
3115  * will always be zero.
3116  *
3117  * A PlaceHolderVar: this works much like the Var case, except that the
3118  * entry is a PlaceHolderVar node with a contained expression. The PHV
3119  * will have phlevelsup = 0, and the contained expression is adjusted
3120  * to match in level.
3121  *
3122  * An Aggref (with an expression tree representing its argument): the slot
3123  * represents an aggregate expression that is an outer reference for some
3124  * subquery. The Aggref itself has agglevelsup = 0, and its argument tree
3125  * is adjusted to match in level.
3126  *
3127  * Note: we detect duplicate Var and PlaceHolderVar parameters and coalesce
3128  * them into one slot, but we do not bother to do that for Aggrefs.
3129  * The scope of duplicate-elimination only extends across the set of
3130  * parameters passed from one query level into a single subquery, or for
3131  * nestloop parameters across the set of nestloop parameters used in a single
3132  * query level. So there is no possibility of a PARAM_EXEC slot being used
3133  * for conflicting purposes.
3134  *
3135  * In addition, PARAM_EXEC slots are assigned for Params representing outputs
3136  * from subplans (values that are setParam items for those subplans). These
3137  * IDs need not be tracked via PlannerParamItems, since we do not need any
3138  * duplicate-elimination nor later processing of the represented expressions.
3139  * Instead, we just record the assignment of the slot number by appending to
3140  * root->glob->paramExecTypes.
3141  */
3142 typedef struct PlannerParamItem
3143 {
3144  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
3145 
3146  NodeTag type;
3147 
3148  Node *item; /* the Var, PlaceHolderVar, or Aggref */
3149  int paramId; /* its assigned PARAM_EXEC slot number */
3151 
3152 /*
3153  * When making cost estimates for a SEMI/ANTI/inner_unique join, there are
3154  * some correction factors that are needed in both nestloop and hash joins
3155  * to account for the fact that the executor can stop scanning inner rows
3156  * as soon as it finds a match to the current outer row. These numbers
3157  * depend only on the selected outer and inner join relations, not on the
3158  * particular paths used for them, so it's worthwhile to calculate them
3159  * just once per relation pair not once per considered path. This struct
3160  * is filled by compute_semi_anti_join_factors and must be passed along
3161  * to the join cost estimation functions.
3162  *
3163  * outer_match_frac is the fraction of the outer tuples that are
3164  * expected to have at least one match.
3165  * match_count is the average number of matches expected for
3166  * outer tuples that have at least one match.
3167  */
3168 typedef struct SemiAntiJoinFactors
3169 {
3173 
3174 /*
3175  * Struct for extra information passed to subroutines of add_paths_to_joinrel
3176  *
3177  * restrictlist contains all of the RestrictInfo nodes for restriction
3178  * clauses that apply to this join
3179  * mergeclause_list is a list of RestrictInfo nodes for available
3180  * mergejoin clauses in this join
3181  * inner_unique is true if each outer tuple provably matches no more
3182  * than one inner tuple
3183  * sjinfo is extra info about special joins for selectivity estimation
3184  * semifactors is as shown above (only valid for SEMI/ANTI/inner_unique joins)
3185  * param_source_rels are OK targets for parameterization of result paths
3186  */
3187 typedef struct JoinPathExtraData
3188 {
3196 
3197 /*
3198  * Various flags indicating what kinds of grouping are possible.
3199  *
3200  * GROUPING_CAN_USE_SORT should be set if it's possible to perform
3201  * sort-based implementations of grouping. When grouping sets are in use,
3202  * this will be true if sorting is potentially usable for any of the grouping
3203  * sets, even if it's not usable for all of them.
3204  *
3205  * GROUPING_CAN_USE_HASH should be set if it's possible to perform
3206  * hash-based implementations of grouping.
3207  *
3208  * GROUPING_CAN_PARTIAL_AGG should be set if the aggregation is of a type
3209  * for which we support partial aggregation (not, for example, grouping sets).
3210  * It says nothing about parallel-safety or the availability of suitable paths.
3211  */
3212 #define GROUPING_CAN_USE_SORT 0x0001
3213 #define GROUPING_CAN_USE_HASH 0x0002
3214 #define GROUPING_CAN_PARTIAL_AGG 0x0004
3215 
3216 /*
3217  * What kind of partitionwise aggregation is in use?
3218  *
3219  * PARTITIONWISE_AGGREGATE_NONE: Not used.
3220  *
3221  * PARTITIONWISE_AGGREGATE_FULL: Aggregate each partition separately, and
3222  * append the results.
3223  *
3224  * PARTITIONWISE_AGGREGATE_PARTIAL: Partially aggregate each partition
3225  * separately, append the results, and then finalize aggregation.
3226  */
3227 typedef enum
3228 {
3233 
3234 /*
3235  * Struct for extra information passed to subroutines of create_grouping_paths
3236  *
3237  * flags indicating what kinds of grouping are possible.
3238  * partial_costs_set is true if the agg_partial_costs and agg_final_costs
3239  * have been initialized.
3240  * agg_partial_costs gives partial aggregation costs.
3241  * agg_final_costs gives finalization costs.
3242  * target_parallel_safe is true if target is parallel safe.
3243  * havingQual gives list of quals to be applied after aggregation.
3244  * targetList gives list of columns to be projected.
3245  * patype is the type of partitionwise aggregation that is being performed.
3246  */
3247 typedef struct
3248 {
3249  /* Data which remains constant once set. */
3250  int flags;
3254 
3255  /* Data which may differ across partitions. */
3261 
3262 /*
3263  * Struct for extra information passed to subroutines of grouping_planner
3264  *
3265  * limit_needed is true if we actually need a Limit plan node.
3266  * limit_tuples is an estimated bound on the number of output tuples,
3267  * or -1 if no LIMIT or couldn't estimate.
3268  * count_est and offset_est are the estimated values of the LIMIT and OFFSET
3269  * expressions computed by preprocess_limit() (see comments for
3270  * preprocess_limit() for more information).
3271  */
3272 typedef struct
3273 {
3276  int64 count_est;
3277  int64 offset_est;
3279 
3280 /*
3281  * For speed reasons, cost estimation for join paths is performed in two
3282  * phases: the first phase tries to quickly derive a lower bound for the
3283  * join cost, and then we check if that's sufficient to reject the path.
3284  * If not, we come back for a more refined cost estimate. The first phase
3285  * fills a JoinCostWorkspace struct with its preliminary cost estimates
3286  * and possibly additional intermediate values. The second phase takes
3287  * these values as inputs to avoid repeating work.
3288  *
3289  * (Ideally we'd declare this in cost.h, but it's also needed in pathnode.h,
3290  * so seems best to put it here.)
3291  */
3292 typedef struct JoinCostWorkspace
3293 {
3294  /* Preliminary cost estimates --- must not be larger than final ones! */
3295  Cost startup_cost; /* cost expended before fetching any tuples */
3296  Cost total_cost; /* total cost (assuming all tuples fetched) */
3297 
3298  /* Fields below here should be treated as private to costsize.c */
3299  Cost run_cost; /* non-startup cost components */
3300 
3301  /* private for cost_nestloop code */
3302  Cost inner_run_cost; /* also used by cost_mergejoin code */
3304 
3305  /* private for cost_mergejoin code */
3310 
3311  /* private for cost_hashjoin code */
3316 
3317 /*
3318  * AggInfo holds information about an aggregate that needs to be computed.
3319  * Multiple Aggrefs in a query can refer to the same AggInfo by having the
3320  * same 'aggno' value, so that the aggregate is computed only once.
3321  */
3322 typedef struct AggInfo
3323 {
3324  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
3325 
3326  NodeTag type;
3327 
3328  /*
3329  * List of Aggref exprs that this state value is for.
3330  *
3331  * There will always be at least one, but there can be multiple identical
3332  * Aggref's sharing the same per-agg.
3333  */
3335 
3336  /* Transition state number for this aggregate */
3337  int transno;
3338 
3339  /*
3340  * "shareable" is false if this agg cannot share state values with other
3341  * aggregates because the final function is read-write.
3342  */
3344 
3345  /* Oid of the final function, or InvalidOid if none */
3348 
3349 /*
3350  * AggTransInfo holds information about transition state that is used by one
3351  * or more aggregates in the query. Multiple aggregates can share the same
3352  * transition state, if they have the same inputs and the same transition
3353  * function. Aggrefs that share the same transition info have the same
3354  * 'aggtransno' value.
3355  */
3356 typedef struct AggTransInfo
3357 {
3358  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
3359 
3360  NodeTag type;
3361 
3362  /* Inputs for this transition state */
3365 
3366  /* Oid of the state transition function */
3368 
3369  /* Oid of the serialization function, or InvalidOid if none */
3371 
3372  /* Oid of the deserialization function, or InvalidOid if none */
3374 
3375  /* Oid of the combine function, or InvalidOid if none */
3377 
3378  /* Oid of state value's datatype */
3380 
3381  /* Additional data about transtype */
3385 
3386  /* Space-consumption estimate */
3388 
3389  /* Initial value from pg_aggregate entry */
3390  Datum initValue pg_node_attr(read_write_ignore);
3393 
3394 /*
3395  * UniqueRelInfo caches a fact that a relation is unique when being joined
3396  * to other relation(s).
3397  */
3398 typedef struct UniqueRelInfo
3399 {
3400  pg_node_attr(no_copy_equal, no_read, no_query_jumble)
3401 
3402  NodeTag type;
3403 
3404  /*
3405  * The relation in consideration is unique when being joined with this set
3406  * of other relation(s).
3407  */
3409 
3410  /*
3411  * Additional clauses from a baserestrictinfo list that were used to prove
3412  * the uniqueness. We cache it for the self-join checking procedure: a
3413  * self-join can be removed if the outer relation contains strictly the
3414  * same set of clauses.
3415  */
3418 
3419 #endif /* PATHNODES_H */
int16 AttrNumber
Definition: attnum.h:21
uint32 BlockNumber
Definition: block.h:31
unsigned int uint32
Definition: c.h:495
signed short int16
Definition: c.h:482
signed int int32
Definition: c.h:483
unsigned int Index
Definition: c.h:603
size_t Size
Definition: c.h:594
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:1005
struct AggTransInfo AggTransInfo
struct MergeScanSelCache MergeScanSelCache
struct IndexPath IndexPath
struct TidRangePath TidRangePath
struct JoinCostWorkspace JoinCostWorkspace
bool is_dummy_rel(RelOptInfo *rel)
Definition: joinrels.c:1314
PartitionwiseAggregateType
Definition: pathnodes.h:3228
@ PARTITIONWISE_AGGREGATE_PARTIAL
Definition: pathnodes.h:3231
@ PARTITIONWISE_AGGREGATE_FULL
Definition: pathnodes.h:3230
@ PARTITIONWISE_AGGREGATE_NONE
Definition: pathnodes.h:3229
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:1987
@ UNIQUE_PATH_SORT
Definition: pathnodes.h:1990
@ UNIQUE_PATH_NOOP
Definition: pathnodes.h:1988
@ UNIQUE_PATH_HASH
Definition: pathnodes.h:1989
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 UniqueRelInfo UniqueRelInfo
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:3343
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
List * aggrefs
Definition: pathnodes.h:3334
int transno
Definition: pathnodes.h:3337
Oid finalfn_oid
Definition: pathnodes.h:3346
Path * subpath
Definition: pathnodes.h:2222
Cardinality numGroups
Definition: pathnodes.h:2225
AggSplit aggsplit
Definition: pathnodes.h:2224
List * groupClause
Definition: pathnodes.h:2227
uint64 transitionSpace
Definition: pathnodes.h:2226
AggStrategy aggstrategy
Definition: pathnodes.h:2223
Path path
Definition: pathnodes.h:2221
List * qual
Definition: pathnodes.h:2228
List * args
Definition: pathnodes.h:3363
int32 aggtransspace
Definition: pathnodes.h:3387
bool transtypeByVal
Definition: pathnodes.h:3384
Oid combinefn_oid
Definition: pathnodes.h:3376
Oid deserialfn_oid
Definition: pathnodes.h:3373
int32 aggtranstypmod
Definition: pathnodes.h:3382
int transtypeLen
Definition: pathnodes.h:3383
bool initValueIsNull
Definition: pathnodes.h:3391
Oid serialfn_oid
Definition: pathnodes.h:3370
Oid aggtranstype
Definition: pathnodes.h:3379
Expr * aggfilter
Definition: pathnodes.h:3364
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:1902
Cardinality limit_tuples
Definition: pathnodes.h:1903
List * subpaths
Definition: pathnodes.h:1900
Index child_relid
Definition: pathnodes.h:2929
List * translated_vars
Definition: pathnodes.h:2956
Index parent_relid
Definition: pathnodes.h:2928
int num_child_cols
Definition: pathnodes.h:2964
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:2937
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:1879
List * custom_paths
Definition: pathnodes.h:1876
uint32 flags
Definition: pathnodes.h:1874
List * custom_private
Definition: pathnodes.h:1878
List * custom_restrictinfo
Definition: pathnodes.h:1877
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:3275
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:1838
List * fdw_restrictinfo
Definition: pathnodes.h:1839
List * fdw_private
Definition: pathnodes.h:1840
bool single_copy
Definition: pathnodes.h:2011
Path * subpath
Definition: pathnodes.h:2010
int num_workers
Definition: pathnodes.h:2012
PartitionwiseAggregateType patype
Definition: pathnodes.h:3259
AggClauseCosts agg_final_costs
Definition: pathnodes.h:3253
AggClauseCosts agg_partial_costs
Definition: pathnodes.h:3252
List * qual
Definition: pathnodes.h:2196
List * groupClause
Definition: pathnodes.h:2195
Path * subpath
Definition: pathnodes.h:2194
Path path
Definition: pathnodes.h:2193
Cardinality numGroups
Definition: pathnodes.h:2241
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
uint64 transitionSpace
Definition: pathnodes.h:2268
AggStrategy aggstrategy
Definition: pathnodes.h:2265
Definition: dynahash.c:220
List * path_hashclauses
Definition: pathnodes.h:2120
Cardinality inner_rows_total
Definition: pathnodes.h:2122
int num_batches
Definition: pathnodes.h:2121
JoinPath jpath
Definition: pathnodes.h:2119
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:3307
Cardinality outer_rows
Definition: pathnodes.h:3306
Cost inner_rescan_run_cost
Definition: pathnodes.h:3303
Cardinality inner_skip_rows
Definition: pathnodes.h:3309
Cardinality inner_rows_total
Definition: pathnodes.h:3314
Cardinality outer_skip_rows
Definition: pathnodes.h:3308
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:3190
Relids param_source_rels
Definition: pathnodes.h:3194
SemiAntiJoinFactors semifactors
Definition: pathnodes.h:3193
SpecialJoinInfo * sjinfo
Definition: pathnodes.h:3192
pg_node_attr(abstract) Path path
Path * outerjoinpath
Definition: pathnodes.h:2042
Path * innerjoinpath
Definition: pathnodes.h:2043
JoinType jointype
Definition: pathnodes.h:2037
bool inner_unique
Definition: pathnodes.h:2039
List * joinrestrictinfo
Definition: pathnodes.h:2045
Path path
Definition: pathnodes.h:2365
Path * subpath
Definition: pathnodes.h:2366
LimitOption limitOption
Definition: pathnodes.h:2369
Node * limitOffset
Definition: pathnodes.h:2367
Node * limitCount
Definition: pathnodes.h:2368
Definition: pg_list.h:54
Path * subpath
Definition: pathnodes.h:2328
List * rowMarks
Definition: pathnodes.h:2329
Path * subpath
Definition: pathnodes.h:1950
bool singlerow
Definition: pathnodes.h:1964
List * hash_operators
Definition: pathnodes.h:1962
uint32 est_entries
Definition: pathnodes.h:1969
bool binary_mode
Definition: pathnodes.h:1966
Cardinality calls
Definition: pathnodes.h:1968
Path * subpath
Definition: pathnodes.h:1961
List * param_exprs
Definition: pathnodes.h:1963
Cardinality limit_tuples
Definition: pathnodes.h:1925
List * outersortkeys
Definition: pathnodes.h:2102
bool skip_mark_restore
Definition: pathnodes.h:2104
List * innersortkeys
Definition: pathnodes.h:2103
JoinPath jpath
Definition: pathnodes.h:2100
bool materialize_inner
Definition: pathnodes.h:2105
List * path_mergeclauses
Definition: pathnodes.h:2101
Selectivity leftstartsel
Definition: pathnodes.h:2702
Selectivity leftendsel
Definition: pathnodes.h:2703
Selectivity rightendsel
Definition: pathnodes.h:2705
Selectivity rightstartsel
Definition: pathnodes.h:2704
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
Param * param
Definition: pathnodes.h:3092
Expr * target
Definition: pathnodes.h:3077
PlannerInfo *subroot pg_node_attr(read_write_ignore)
List * quals
Definition: pathnodes.h:2278
List * mmaggregates
Definition: pathnodes.h:2277
bool partColsUpdated
Definition: pathnodes.h:2348
List * returningLists
Definition: pathnodes.h:2352
List * resultRelations
Definition: pathnodes.h:2349
List * withCheckOptionLists
Definition: pathnodes.h:2351
List * updateColnosLists
Definition: pathnodes.h:2350
OnConflictExpr * onconflict
Definition: pathnodes.h:2354
CmdType operation
Definition: pathnodes.h:2344
Index rootRelation
Definition: pathnodes.h:2347
Index nominalRelation
Definition: pathnodes.h:2346
List * mergeActionLists
Definition: pathnodes.h:2356
JoinPath jpath
Definition: pathnodes.h:2060
Definition: nodes.h:129
RestrictInfo * rinfo
Definition: pathnodes.h:2882
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
SpecialJoinInfo * sjinfo
Definition: pathnodes.h:2883
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:3050
Relids ph_needed
Definition: pathnodes.h:3053
pg_node_attr(no_read, no_query_jumble) NodeTag type
Relids ph_eval_at
Definition: pathnodes.h:3047
PlaceHolderVar * ph_var
Definition: pathnodes.h:3044
Relids phrels pg_node_attr(equal_ignore)
Relids phnullingrels
Definition: pathnodes.h:2753
pg_node_attr(no_query_jumble) Expr xpr
Expr *phexpr pg_node_attr(equal_ignore)
Index phlevelsup
Definition: pathnodes.h:2759
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:2154
Path * subpath
Definition: pathnodes.h:2142
Cost per_tuple
Definition: pathnodes.h:48
Cost startup
Definition: pathnodes.h:47
Cardinality numGroups
Definition: pathnodes.h:2319
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:2532
Index security_level
Definition: pathnodes.h:2551
EquivalenceClass *left_ec pg_node_attr(copy_as_scalar, equal_ignore, read_write_ignore)
Relids required_relids
Definition: pathnodes.h:2560
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:2598
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:2566
Relids incompatible_relids
Definition: pathnodes.h:2563
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:2529
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:2541
Expr *orclause pg_node_attr(equal_ignore)
Cardinality numGroups
Definition: pathnodes.h:2252
List * groupClause
Definition: pathnodes.h:2249
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
List * gsets_data
Definition: pathnodes.h:2251
bool hashable
Definition: pathnodes.h:2253
List * gsets
Definition: pathnodes.h:2250
bool is_hashed
Definition: pathnodes.h:2254
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
Selectivity outer_match_frac
Definition: pathnodes.h:3170
Selectivity match_count
Definition: pathnodes.h:3171
List * distinctList
Definition: pathnodes.h:2303
Cardinality numGroups
Definition: pathnodes.h:2306
int firstFlag
Definition: pathnodes.h:2305
Path * subpath
Definition: pathnodes.h:2300
SetOpCmd cmd
Definition: pathnodes.h:2301
Path path
Definition: pathnodes.h:2299
SetOpStrategy strategy
Definition: pathnodes.h:2302
AttrNumber flagColIdx
Definition: pathnodes.h:2304
Path path
Definition: pathnodes.h:2167
Path * subpath
Definition: pathnodes.h:2168
Relids commute_above_r
Definition: pathnodes.h:2860
Relids syn_lefthand
Definition: pathnodes.h:2855
Relids min_righthand
Definition: pathnodes.h:2854
List * semi_rhs_exprs
Definition: pathnodes.h:2868
Relids commute_above_l
Definition: pathnodes.h:2859
JoinType jointype
Definition: pathnodes.h:2857
Relids commute_below_l
Definition: pathnodes.h:2861
Relids min_lefthand
Definition: pathnodes.h:2853
Relids syn_righthand
Definition: pathnodes.h:2856
pg_node_attr(no_read, no_query_jumble) NodeTag type
Relids commute_below_r
Definition: pathnodes.h:2862
List * semi_operators
Definition: pathnodes.h:2867
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:1996
List * uniq_exprs
Definition: pathnodes.h:1999
UniquePathMethod umethod
Definition: pathnodes.h:1997
List * in_operators
Definition: pathnodes.h:1998
pg_node_attr(no_copy_equal, no_read, no_query_jumble) NodeTag type
Relids outerrelids
Definition: pathnodes.h:3408
List * extra_clauses
Definition: pathnodes.h:3416
Definition: primnodes.h:234
Path * subpath
Definition: pathnodes.h:2287
WindowClause * winclause
Definition: pathnodes.h:2288
Definition: c.h:676
const char * type