PostgreSQL Source Code  git master
planmain.c File Reference
Include dependency graph for planmain.c:

Go to the source code of this file.

Functions

RelOptInfoquery_planner (PlannerInfo *root, query_pathkeys_callback qp_callback, void *qp_extra)
 

Function Documentation

◆ query_planner()

RelOptInfo* query_planner ( PlannerInfo root,
query_pathkeys_callback  qp_callback,
void *  qp_extra 
)

Definition at line 54 of file planmain.c.

56 {
57  Query *parse = root->parse;
58  List *joinlist;
59  RelOptInfo *final_rel;
60 
61  /*
62  * Init planner lists to empty.
63  *
64  * NOTE: append_rel_list was set up by subquery_planner, so do not touch
65  * here.
66  */
67  root->join_rel_list = NIL;
68  root->join_rel_hash = NULL;
69  root->join_rel_level = NULL;
70  root->join_cur_level = 0;
71  root->canon_pathkeys = NIL;
72  root->left_join_clauses = NIL;
73  root->right_join_clauses = NIL;
74  root->full_join_clauses = NIL;
75  root->join_info_list = NIL;
76  root->placeholder_list = NIL;
77  root->placeholder_array = NULL;
78  root->placeholder_array_size = 0;
79  root->fkey_list = NIL;
80  root->initial_rels = NIL;
81 
82  /*
83  * Set up arrays for accessing base relations and AppendRelInfos.
84  */
86 
87  /*
88  * In the trivial case where the jointree is a single RTE_RESULT relation,
89  * bypass all the rest of this function and just make a RelOptInfo and its
90  * one access path. This is worth optimizing because it applies for
91  * common cases like "SELECT expression" and "INSERT ... VALUES()".
92  */
93  Assert(parse->jointree->fromlist != NIL);
94  if (list_length(parse->jointree->fromlist) == 1)
95  {
96  Node *jtnode = (Node *) linitial(parse->jointree->fromlist);
97 
98  if (IsA(jtnode, RangeTblRef))
99  {
100  int varno = ((RangeTblRef *) jtnode)->rtindex;
101  RangeTblEntry *rte = root->simple_rte_array[varno];
102 
103  Assert(rte != NULL);
104  if (rte->rtekind == RTE_RESULT)
105  {
106  /* Make the RelOptInfo for it directly */
107  final_rel = build_simple_rel(root, varno, NULL);
108 
109  /*
110  * If query allows parallelism in general, check whether the
111  * quals are parallel-restricted. (We need not check
112  * final_rel->reltarget because it's empty at this point.
113  * Anything parallel-restricted in the query tlist will be
114  * dealt with later.) We should always do this in a subquery,
115  * since it might be useful to use the subquery in parallel
116  * paths in the parent level. At top level this is normally
117  * not worth the cycles, because a Result-only plan would
118  * never be interesting to parallelize. However, if
119  * debug_parallel_query is on, then we want to execute the
120  * Result in a parallel worker if possible, so we must check.
121  */
122  if (root->glob->parallelModeOK &&
123  (root->query_level > 1 ||
125  final_rel->consider_parallel =
126  is_parallel_safe(root, parse->jointree->quals);
127 
128  /*
129  * The only path for it is a trivial Result path. We cheat a
130  * bit here by using a GroupResultPath, because that way we
131  * can just jam the quals into it without preprocessing them.
132  * (But, if you hold your head at the right angle, a FROM-less
133  * SELECT is a kind of degenerate-grouping case, so it's not
134  * that much of a cheat.)
135  */
136  add_path(final_rel, (Path *)
137  create_group_result_path(root, final_rel,
138  final_rel->reltarget,
139  (List *) parse->jointree->quals));
140 
141  /* Select cheapest path (pretty easy in this case...) */
142  set_cheapest(final_rel);
143 
144  /*
145  * We don't need to run generate_base_implied_equalities, but
146  * we do need to pretend that EC merging is complete.
147  */
148  root->ec_merging_done = true;
149 
150  /*
151  * We still are required to call qp_callback, in case it's
152  * something like "SELECT 2+2 ORDER BY 1".
153  */
154  (*qp_callback) (root, qp_extra);
155 
156  return final_rel;
157  }
158  }
159  }
160 
161  /*
162  * Construct RelOptInfo nodes for all base relations used in the query.
163  * Appendrel member relations ("other rels") will be added later.
164  *
165  * Note: the reason we find the baserels by searching the jointree, rather
166  * than scanning the rangetable, is that the rangetable may contain RTEs
167  * for rels not actively part of the query, for example views. We don't
168  * want to make RelOptInfos for them.
169  */
170  add_base_rels_to_query(root, (Node *) parse->jointree);
171 
172  /*
173  * Examine the targetlist and join tree, adding entries to baserel
174  * targetlists for all referenced Vars, and generating PlaceHolderInfo
175  * entries for all referenced PlaceHolderVars. Restrict and join clauses
176  * are added to appropriate lists belonging to the mentioned relations. We
177  * also build EquivalenceClasses for provably equivalent expressions. The
178  * SpecialJoinInfo list is also built to hold information about join order
179  * restrictions. Finally, we form a target joinlist for make_one_rel() to
180  * work from.
181  */
182  build_base_rel_tlists(root, root->processed_tlist);
183 
185 
187 
188  joinlist = deconstruct_jointree(root);
189 
190  /*
191  * Reconsider any postponed outer-join quals now that we have built up
192  * equivalence classes. (This could result in further additions or
193  * mergings of classes.)
194  */
196 
197  /*
198  * If we formed any equivalence classes, generate additional restriction
199  * clauses as appropriate. (Implied join clauses are formed on-the-fly
200  * later.)
201  */
203 
204  /*
205  * We have completed merging equivalence sets, so it's now possible to
206  * generate pathkeys in canonical form; so compute query_pathkeys and
207  * other pathkeys fields in PlannerInfo.
208  */
209  (*qp_callback) (root, qp_extra);
210 
211  /*
212  * Examine any "placeholder" expressions generated during subquery pullup.
213  * Make sure that the Vars they need are marked as needed at the relevant
214  * join level. This must be done before join removal because it might
215  * cause Vars or placeholders to be needed above a join when they weren't
216  * so marked before.
217  */
219 
220  /*
221  * Remove any useless outer joins. Ideally this would be done during
222  * jointree preprocessing, but the necessary information isn't available
223  * until we've built baserel data structures and classified qual clauses.
224  */
225  joinlist = remove_useless_joins(root, joinlist);
226 
227  /*
228  * Also, reduce any semijoins with unique inner rels to plain inner joins.
229  * Likewise, this can't be done until now for lack of needed info.
230  */
232 
233  /*
234  * Now distribute "placeholders" to base rels as needed. This has to be
235  * done after join removal because removal could change whether a
236  * placeholder is evaluable at a base rel.
237  */
239 
240  /*
241  * Construct the lateral reference sets now that we have finalized
242  * PlaceHolderVar eval levels.
243  */
245 
246  /*
247  * Match foreign keys to equivalence classes and join quals. This must be
248  * done after finalizing equivalence classes, and it's useful to wait till
249  * after join removal so that we can skip processing foreign keys
250  * involving removed relations.
251  */
253 
254  /*
255  * Look for join OR clauses that we can extract single-relation
256  * restriction OR clauses from.
257  */
259 
260  /*
261  * Now expand appendrels by adding "otherrels" for their children. We
262  * delay this to the end so that we have as much information as possible
263  * available for each baserel, including all restriction clauses. That
264  * let us prune away partitions that don't satisfy a restriction clause.
265  * Also note that some information such as lateral_relids is propagated
266  * from baserels to otherrels here, so we must have computed it already.
267  */
269 
270  /*
271  * Distribute any UPDATE/DELETE/MERGE row identity variables to the target
272  * relations. This can't be done till we've finished expansion of
273  * appendrels.
274  */
276 
277  /*
278  * Ready to do the primary planning.
279  */
280  final_rel = make_one_rel(root, joinlist);
281 
282  /* Check that we got at least one usable path */
283  if (!final_rel || !final_rel->cheapest_total_path ||
284  final_rel->cheapest_total_path->param_info != NULL)
285  elog(ERROR, "failed to construct the join relation");
286 
287  return final_rel;
288 }
RelOptInfo * make_one_rel(PlannerInfo *root, List *joinlist)
Definition: allpaths.c:171
List * remove_useless_joins(PlannerInfo *root, List *joinlist)
Definition: analyzejoins.c:64
void reduce_unique_semijoins(PlannerInfo *root)
Definition: analyzejoins.c:730
void distribute_row_identity_vars(PlannerInfo *root)
Definition: appendinfo.c:965
#define Assert(condition)
Definition: c.h:858
bool is_parallel_safe(PlannerInfo *root, Node *node)
Definition: clauses.c:753
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
void generate_base_implied_equalities(PlannerInfo *root)
Definition: equivclass.c:1033
void reconsider_outer_join_clauses(PlannerInfo *root)
Definition: equivclass.c:1997
List * deconstruct_jointree(PlannerInfo *root)
Definition: initsplan.c:740
void match_foreign_keys_to_quals(PlannerInfo *root)
Definition: initsplan.c:3169
void find_lateral_references(PlannerInfo *root)
Definition: initsplan.c:358
void add_base_rels_to_query(PlannerInfo *root, Node *jtnode)
Definition: initsplan.c:157
void build_base_rel_tlists(PlannerInfo *root, List *final_tlist)
Definition: initsplan.c:234
void add_other_rels_to_query(PlannerInfo *root)
Definition: initsplan.c:195
void create_lateral_join_info(PlannerInfo *root)
Definition: initsplan.c:501
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
@ DEBUG_PARALLEL_OFF
Definition: optimizer.h:106
void extract_restriction_or_clauses(PlannerInfo *root)
Definition: orclauses.c:75
@ RTE_RESULT
Definition: parsenodes.h:1036
GroupResultPath * create_group_result_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *havingqual)
Definition: pathnode.c:1518
void set_cheapest(RelOptInfo *parent_rel)
Definition: pathnode.c:242
void add_path(RelOptInfo *parent_rel, Path *new_path)
Definition: pathnode.c:420
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define linitial(l)
Definition: pg_list.h:178
void add_placeholders_to_base_rels(PlannerInfo *root)
Definition: placeholder.c:329
void fix_placeholder_input_needed_levels(PlannerInfo *root)
Definition: placeholder.c:300
void find_placeholders_in_jointree(PlannerInfo *root)
Definition: placeholder.c:185
int debug_parallel_query
Definition: planner.c:67
tree ctl root
Definition: radixtree.h:1884
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:715
void setup_simple_rel_arrays(PlannerInfo *root)
Definition: relnode.c:94
RelOptInfo * build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
Definition: relnode.c:192
Definition: pg_list.h:54
Definition: nodes.h:129
RTEKind rtekind
Definition: parsenodes.h:1057
struct PathTarget * reltarget
Definition: pathnodes.h:887
bool consider_parallel
Definition: pathnodes.h:881
struct Path * cheapest_total_path
Definition: pathnodes.h:896

References add_base_rels_to_query(), add_other_rels_to_query(), add_path(), add_placeholders_to_base_rels(), Assert, build_base_rel_tlists(), build_simple_rel(), RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_group_result_path(), create_lateral_join_info(), DEBUG_PARALLEL_OFF, debug_parallel_query, deconstruct_jointree(), distribute_row_identity_vars(), elog, ERROR, extract_restriction_or_clauses(), find_lateral_references(), find_placeholders_in_jointree(), fix_placeholder_input_needed_levels(), generate_base_implied_equalities(), is_parallel_safe(), IsA, linitial, list_length(), make_one_rel(), match_foreign_keys_to_quals(), NIL, parse(), reconsider_outer_join_clauses(), reduce_unique_semijoins(), RelOptInfo::reltarget, remove_useless_joins(), root, RTE_RESULT, RangeTblEntry::rtekind, set_cheapest(), and setup_simple_rel_arrays().

Referenced by build_minmax_path(), and grouping_planner().