PostgreSQL Source Code git master
allpaths.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * allpaths.c
4 * Routines to find possible search paths for processing a query
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/optimizer/path/allpaths.c
12 *
13 *-------------------------------------------------------------------------
14 */
15
16#include "postgres.h"
17
18#include <limits.h>
19#include <math.h>
20
21#include "access/sysattr.h"
22#include "access/tsmapi.h"
23#include "catalog/pg_class.h"
24#include "catalog/pg_operator.h"
25#include "catalog/pg_proc.h"
26#include "foreign/fdwapi.h"
27#include "miscadmin.h"
28#include "nodes/makefuncs.h"
29#include "nodes/nodeFuncs.h"
30#include "nodes/supportnodes.h"
31#ifdef OPTIMIZER_DEBUG
32#include "nodes/print.h"
33#endif
34#include "optimizer/appendinfo.h"
35#include "optimizer/clauses.h"
36#include "optimizer/cost.h"
37#include "optimizer/geqo.h"
38#include "optimizer/optimizer.h"
39#include "optimizer/pathnode.h"
40#include "optimizer/paths.h"
41#include "optimizer/plancat.h"
42#include "optimizer/planner.h"
43#include "optimizer/tlist.h"
44#include "parser/parse_clause.h"
45#include "parser/parsetree.h"
46#include "partitioning/partbounds.h"
47#include "port/pg_bitutils.h"
48#include "rewrite/rewriteManip.h"
49#include "utils/lsyscache.h"
50
51
52/* Bitmask flags for pushdown_safety_info.unsafeFlags */
53#define UNSAFE_HAS_VOLATILE_FUNC (1 << 0)
54#define UNSAFE_HAS_SET_FUNC (1 << 1)
55#define UNSAFE_NOTIN_DISTINCTON_CLAUSE (1 << 2)
56#define UNSAFE_NOTIN_PARTITIONBY_CLAUSE (1 << 3)
57#define UNSAFE_TYPE_MISMATCH (1 << 4)
58
59/* results of subquery_is_pushdown_safe */
60typedef struct pushdown_safety_info
61{
62 unsigned char *unsafeFlags; /* bitmask of reasons why this target list
63 * column is unsafe for qual pushdown, or 0 if
64 * no reason. */
65 bool unsafeVolatile; /* don't push down volatile quals */
66 bool unsafeLeaky; /* don't push down leaky quals */
67} pushdown_safety_info;
68
69/* Return type for qual_is_pushdown_safe */
70typedef enum pushdown_safe_type
71{
72 PUSHDOWN_UNSAFE, /* unsafe to push qual into subquery */
73 PUSHDOWN_SAFE, /* safe to push qual into subquery */
74 PUSHDOWN_WINDOWCLAUSE_RUNCOND, /* unsafe, but may work as WindowClause
75 * run condition */
76} pushdown_safe_type;
77
78/* These parameters are set by GUC */
79bool enable_geqo = false; /* just in case GUC doesn't set it */
80int geqo_threshold;
81int min_parallel_table_scan_size;
82int min_parallel_index_scan_size;
83
84/* Hook for plugins to get control in set_rel_pathlist() */
85set_rel_pathlist_hook_type set_rel_pathlist_hook = NULL;
86
87/* Hook for plugins to replace standard_join_search() */
88join_search_hook_type join_search_hook = NULL;
89
90
91static void set_base_rel_consider_startup(PlannerInfo *root);
92static void set_base_rel_sizes(PlannerInfo *root);
93static void set_base_rel_pathlists(PlannerInfo *root);
94static void set_rel_size(PlannerInfo *root, RelOptInfo *rel,
95 Index rti, RangeTblEntry *rte);
96static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
97 Index rti, RangeTblEntry *rte);
98static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel,
99 RangeTblEntry *rte);
100static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel);
101static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel,
102 RangeTblEntry *rte);
103static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
104 RangeTblEntry *rte);
105static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel,
106 RangeTblEntry *rte);
107static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
108 RangeTblEntry *rte);
109static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel,
110 RangeTblEntry *rte);
111static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel,
112 RangeTblEntry *rte);
113static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
114 Index rti, RangeTblEntry *rte);
115static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
116 Index rti, RangeTblEntry *rte);
117static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
118 List *live_childrels,
119 List *all_child_pathkeys);
120static Path *get_cheapest_parameterized_child_path(PlannerInfo *root,
121 RelOptInfo *rel,
122 Relids required_outer);
123static void accumulate_append_subpath(Path *path,
124 List **subpaths,
125 List **special_subpaths);
126static Path *get_singleton_append_subpath(Path *path);
127static void set_dummy_rel_pathlist(RelOptInfo *rel);
128static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
129 Index rti, RangeTblEntry *rte);
130static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel,
131 RangeTblEntry *rte);
132static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel,
133 RangeTblEntry *rte);
134static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel,
135 RangeTblEntry *rte);
136static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel,
137 RangeTblEntry *rte);
138static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
139 RangeTblEntry *rte);
140static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel,
141 RangeTblEntry *rte);
142static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
143 RangeTblEntry *rte);
144static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
145static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
146 pushdown_safety_info *safetyInfo);
147static bool recurse_pushdown_safe(Node *setOp, Query *topquery,
148 pushdown_safety_info *safetyInfo);
149static void check_output_expressions(Query *subquery,
150 pushdown_safety_info *safetyInfo);
151static void compare_tlist_datatypes(List *tlist, List *colTypes,
152 pushdown_safety_info *safetyInfo);
153static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query);
154static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti,
155 RestrictInfo *rinfo,
156 pushdown_safety_info *safetyInfo);
157static void subquery_push_qual(Query *subquery,
158 RangeTblEntry *rte, Index rti, Node *qual);
159static void recurse_push_qual(Node *setOp, Query *topquery,
160 RangeTblEntry *rte, Index rti, Node *qual);
161static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel,
162 Bitmapset *extra_used_attrs);
163
164
165/*
166 * make_one_rel
167 * Finds all possible access paths for executing a query, returning a
168 * single rel that represents the join of all base rels in the query.
169 */
170RelOptInfo *
171make_one_rel(PlannerInfo *root, List *joinlist)
172{
173 RelOptInfo *rel;
174 Index rti;
175 double total_pages;
176
177 /* Mark base rels as to whether we care about fast-start plans */
178 set_base_rel_consider_startup(root);
179
180 /*
181 * Compute size estimates and consider_parallel flags for each base rel.
182 */
183 set_base_rel_sizes(root);
184
185 /*
186 * We should now have size estimates for every actual table involved in
187 * the query, and we also know which if any have been deleted from the
188 * query by join removal, pruned by partition pruning, or eliminated by
189 * constraint exclusion. So we can now compute total_table_pages.
190 *
191 * Note that appendrels are not double-counted here, even though we don't
192 * bother to distinguish RelOptInfos for appendrel parents, because the
193 * parents will have pages = 0.
194 *
195 * XXX if a table is self-joined, we will count it once per appearance,
196 * which perhaps is the wrong thing ... but that's not completely clear,
197 * and detecting self-joins here is difficult, so ignore it for now.
198 */
199 total_pages = 0;
200 for (rti = 1; rti < root->simple_rel_array_size; rti++)
201 {
202 RelOptInfo *brel = root->simple_rel_array[rti];
203
204 /* there may be empty slots corresponding to non-baserel RTEs */
205 if (brel == NULL)
206 continue;
207
208 Assert(brel->relid == rti); /* sanity check on array */
209
210 if (IS_DUMMY_REL(brel))
211 continue;
212
213 if (IS_SIMPLE_REL(brel))
214 total_pages += (double) brel->pages;
215 }
216 root->total_table_pages = total_pages;
217
218 /*
219 * Generate access paths for each base rel.
220 */
221 set_base_rel_pathlists(root);
222
223 /*
224 * Generate access paths for the entire join tree.
225 */
226 rel = make_rel_from_joinlist(root, joinlist);
227
228 /*
229 * The result should join all and only the query's base + outer-join rels.
230 */
231 Assert(bms_equal(rel->relids, root->all_query_rels));
232
233 return rel;
234}
235
236/*
237 * set_base_rel_consider_startup
238 * Set the consider_[param_]startup flags for each base-relation entry.
239 *
240 * For the moment, we only deal with consider_param_startup here; because the
241 * logic for consider_startup is pretty trivial and is the same for every base
242 * relation, we just let build_simple_rel() initialize that flag correctly to
243 * start with. If that logic ever gets more complicated it would probably
244 * be better to move it here.
245 */
246static void
247set_base_rel_consider_startup(PlannerInfo *root)
248{
249 /*
250 * Since parameterized paths can only be used on the inside of a nestloop
251 * join plan, there is usually little value in considering fast-start
252 * plans for them. However, for relations that are on the RHS of a SEMI
253 * or ANTI join, a fast-start plan can be useful because we're only going
254 * to care about fetching one tuple anyway.
255 *
256 * To minimize growth of planning time, we currently restrict this to
257 * cases where the RHS is a single base relation, not a join; there is no
258 * provision for consider_param_startup to get set at all on joinrels.
259 * Also we don't worry about appendrels. costsize.c's costing rules for
260 * nestloop semi/antijoins don't consider such cases either.
261 */
262 ListCell *lc;
263
264 foreach(lc, root->join_info_list)
265 {
266 SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) lfirst(lc);
267 int varno;
268
269 if ((sjinfo->jointype == JOIN_SEMI || sjinfo->jointype == JOIN_ANTI) &&
270 bms_get_singleton_member(sjinfo->syn_righthand, &varno))
271 {
272 RelOptInfo *rel = find_base_rel(root, varno);
273
274 rel->consider_param_startup = true;
275 }
276 }
277}
278
279/*
280 * set_base_rel_sizes
281 * Set the size estimates (rows and widths) for each base-relation entry.
282 * Also determine whether to consider parallel paths for base relations.
283 *
284 * We do this in a separate pass over the base rels so that rowcount
285 * estimates are available for parameterized path generation, and also so
286 * that each rel's consider_parallel flag is set correctly before we begin to
287 * generate paths.
288 */
289static void
290set_base_rel_sizes(PlannerInfo *root)
291{
292 Index rti;
293
294 for (rti = 1; rti < root->simple_rel_array_size; rti++)
295 {
296 RelOptInfo *rel = root->simple_rel_array[rti];
297 RangeTblEntry *rte;
298
299 /* there may be empty slots corresponding to non-baserel RTEs */
300 if (rel == NULL)
301 continue;
302
303 Assert(rel->relid == rti); /* sanity check on array */
304
305 /* ignore RTEs that are "other rels" */
306 if (rel->reloptkind != RELOPT_BASEREL)
307 continue;
308
309 rte = root->simple_rte_array[rti];
310
311 /*
312 * If parallelism is allowable for this query in general, see whether
313 * it's allowable for this rel in particular. We have to do this
314 * before set_rel_size(), because (a) if this rel is an inheritance
315 * parent, set_append_rel_size() will use and perhaps change the rel's
316 * consider_parallel flag, and (b) for some RTE types, set_rel_size()
317 * goes ahead and makes paths immediately.
318 */
319 if (root->glob->parallelModeOK)
320 set_rel_consider_parallel(root, rel, rte);
321
322 set_rel_size(root, rel, rti, rte);
323 }
324}
325
326/*
327 * set_base_rel_pathlists
328 * Finds all paths available for scanning each base-relation entry.
329 * Sequential scan and any available indices are considered.
330 * Each useful path is attached to its relation's 'pathlist' field.
331 */
332static void
333set_base_rel_pathlists(PlannerInfo *root)
334{
335 Index rti;
336
337 for (rti = 1; rti < root->simple_rel_array_size; rti++)
338 {
339 RelOptInfo *rel = root->simple_rel_array[rti];
340
341 /* there may be empty slots corresponding to non-baserel RTEs */
342 if (rel == NULL)
343 continue;
344
345 Assert(rel->relid == rti); /* sanity check on array */
346
347 /* ignore RTEs that are "other rels" */
348 if (rel->reloptkind != RELOPT_BASEREL)
349 continue;
350
351 set_rel_pathlist(root, rel, rti, root->simple_rte_array[rti]);
352 }
353}
354
355/*
356 * set_rel_size
357 * Set size estimates for a base relation
358 */
359static void
360set_rel_size(PlannerInfo *root, RelOptInfo *rel,
361 Index rti, RangeTblEntry *rte)
362{
363 if (rel->reloptkind == RELOPT_BASEREL &&
364 relation_excluded_by_constraints(root, rel, rte))
365 {
366 /*
367 * We proved we don't need to scan the rel via constraint exclusion,
368 * so set up a single dummy path for it. Here we only check this for
369 * regular baserels; if it's an otherrel, CE was already checked in
370 * set_append_rel_size().
371 *
372 * In this case, we go ahead and set up the relation's path right away
373 * instead of leaving it for set_rel_pathlist to do. This is because
374 * we don't have a convention for marking a rel as dummy except by
375 * assigning a dummy path to it.
376 */
377 set_dummy_rel_pathlist(rel);
378 }
379 else if (rte->inh)
380 {
381 /* It's an "append relation", process accordingly */
382 set_append_rel_size(root, rel, rti, rte);
383 }
384 else
385 {
386 switch (rel->rtekind)
387 {
388 case RTE_RELATION:
389 if (rte->relkind == RELKIND_FOREIGN_TABLE)
390 {
391 /* Foreign table */
392 set_foreign_size(root, rel, rte);
393 }
394 else if (rte->relkind == RELKIND_PARTITIONED_TABLE)
395 {
396 /*
397 * We could get here if asked to scan a partitioned table
398 * with ONLY. In that case we shouldn't scan any of the
399 * partitions, so mark it as a dummy rel.
400 */
401 set_dummy_rel_pathlist(rel);
402 }
403 else if (rte->tablesample != NULL)
404 {
405 /* Sampled relation */
406 set_tablesample_rel_size(root, rel, rte);
407 }
408 else
409 {
410 /* Plain relation */
411 set_plain_rel_size(root, rel, rte);
412 }
413 break;
414 case RTE_SUBQUERY:
415
416 /*
417 * Subqueries don't support making a choice between
418 * parameterized and unparameterized paths, so just go ahead
419 * and build their paths immediately.
420 */
421 set_subquery_pathlist(root, rel, rti, rte);
422 break;
423 case RTE_FUNCTION:
424 set_function_size_estimates(root, rel);
425 break;
426 case RTE_TABLEFUNC:
427 set_tablefunc_size_estimates(root, rel);
428 break;
429 case RTE_VALUES:
430 set_values_size_estimates(root, rel);
431 break;
432 case RTE_CTE:
433
434 /*
435 * CTEs don't support making a choice between parameterized
436 * and unparameterized paths, so just go ahead and build their
437 * paths immediately.
438 */
439 if (rte->self_reference)
440 set_worktable_pathlist(root, rel, rte);
441 else
442 set_cte_pathlist(root, rel, rte);
443 break;
444 case RTE_NAMEDTUPLESTORE:
445 /* Might as well just build the path immediately */
446 set_namedtuplestore_pathlist(root, rel, rte);
447 break;
448 case RTE_RESULT:
449 /* Might as well just build the path immediately */
450 set_result_pathlist(root, rel, rte);
451 break;
452 default:
453 elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
454 break;
455 }
456 }
457
458 /*
459 * We insist that all non-dummy rels have a nonzero rowcount estimate.
460 */
461 Assert(rel->rows > 0 || IS_DUMMY_REL(rel));
462}
463
464/*
465 * set_rel_pathlist
466 * Build access paths for a base relation
467 */
468static void
469set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
470 Index rti, RangeTblEntry *rte)
471{
472 if (IS_DUMMY_REL(rel))
473 {
474 /* We already proved the relation empty, so nothing more to do */
475 }
476 else if (rte->inh)
477 {
478 /* It's an "append relation", process accordingly */
479 set_append_rel_pathlist(root, rel, rti, rte);
480 }
481 else
482 {
483 switch (rel->rtekind)
484 {
485 case RTE_RELATION:
486 if (rte->relkind == RELKIND_FOREIGN_TABLE)
487 {
488 /* Foreign table */
489 set_foreign_pathlist(root, rel, rte);
490 }
491 else if (rte->tablesample != NULL)
492 {
493 /* Sampled relation */
494 set_tablesample_rel_pathlist(root, rel, rte);
495 }
496 else
497 {
498 /* Plain relation */
499 set_plain_rel_pathlist(root, rel, rte);
500 }
501 break;
502 case RTE_SUBQUERY:
503 /* Subquery --- fully handled during set_rel_size */
504 break;
505 case RTE_FUNCTION:
506 /* RangeFunction */
507 set_function_pathlist(root, rel, rte);
508 break;
509 case RTE_TABLEFUNC:
510 /* Table Function */
511 set_tablefunc_pathlist(root, rel, rte);
512 break;
513 case RTE_VALUES:
514 /* Values list */
515 set_values_pathlist(root, rel, rte);
516 break;
517 case RTE_CTE:
518 /* CTE reference --- fully handled during set_rel_size */
519 break;
520 case RTE_NAMEDTUPLESTORE:
521 /* tuplestore reference --- fully handled during set_rel_size */
522 break;
523 case RTE_RESULT:
524 /* simple Result --- fully handled during set_rel_size */
525 break;
526 default:
527 elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind);
528 break;
529 }
530 }
531
532 /*
533 * Allow a plugin to editorialize on the set of Paths for this base
534 * relation. It could add new paths (such as CustomPaths) by calling
535 * add_path(), or add_partial_path() if parallel aware. It could also
536 * delete or modify paths added by the core code.
537 */
538 if (set_rel_pathlist_hook)
539 (*set_rel_pathlist_hook) (root, rel, rti, rte);
540
541 /*
542 * If this is a baserel, we should normally consider gathering any partial
543 * paths we may have created for it. We have to do this after calling the
544 * set_rel_pathlist_hook, else it cannot add partial paths to be included
545 * here.
546 *
547 * However, if this is an inheritance child, skip it. Otherwise, we could
548 * end up with a very large number of gather nodes, each trying to grab
549 * its own pool of workers. Instead, we'll consider gathering partial
550 * paths for the parent appendrel.
551 *
552 * Also, if this is the topmost scan/join rel, we postpone gathering until
553 * the final scan/join targetlist is available (see grouping_planner).
554 */
555 if (rel->reloptkind == RELOPT_BASEREL &&
556 !bms_equal(rel->relids, root->all_query_rels))
557 generate_useful_gather_paths(root, rel, false);
558
559 /* Now find the cheapest of the paths for this rel */
560 set_cheapest(rel);
561
562#ifdef OPTIMIZER_DEBUG
563 pprint(rel);
564#endif
565}
566
567/*
568 * set_plain_rel_size
569 * Set size estimates for a plain relation (no subquery, no inheritance)
570 */
571static void
572set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
573{
574 /*
575 * Test any partial indexes of rel for applicability. We must do this
576 * first since partial unique indexes can affect size estimates.
577 */
578 check_index_predicates(root, rel);
579
580 /* Mark rel with estimated output rows, width, etc */
581 set_baserel_size_estimates(root, rel);
582}
583
584/*
585 * If this relation could possibly be scanned from within a worker, then set
586 * its consider_parallel flag.
587 */
588static void
589set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel,
590 RangeTblEntry *rte)
591{
592 /*
593 * The flag has previously been initialized to false, so we can just
594 * return if it becomes clear that we can't safely set it.
595 */
596 Assert(!rel->consider_parallel);
597
598 /* Don't call this if parallelism is disallowed for the entire query. */
599 Assert(root->glob->parallelModeOK);
600
601 /* This should only be called for baserels and appendrel children. */
602 Assert(IS_SIMPLE_REL(rel));
603
604 /* Assorted checks based on rtekind. */
605 switch (rte->rtekind)
606 {
607 case RTE_RELATION:
608
609 /*
610 * Currently, parallel workers can't access the leader's temporary
611 * tables. We could possibly relax this if we wrote all of its
612 * local buffers at the start of the query and made no changes
613 * thereafter (maybe we could allow hint bit changes), and if we
614 * taught the workers to read them. Writing a large number of
615 * temporary buffers could be expensive, though, and we don't have
616 * the rest of the necessary infrastructure right now anyway. So
617 * for now, bail out if we see a temporary table.
618 */
619 if (get_rel_persistence(rte->relid) == RELPERSISTENCE_TEMP)
620 return;
621
622 /*
623 * Table sampling can be pushed down to workers if the sample
624 * function and its arguments are safe.
625 */
626 if (rte->tablesample != NULL)
627 {
628 char proparallel = func_parallel(rte->tablesample->tsmhandler);
629
630 if (proparallel != PROPARALLEL_SAFE)
631 return;
632 if (!is_parallel_safe(root, (Node *) rte->tablesample->args))
633 return;
634 }
635
636 /*
637 * Ask FDWs whether they can support performing a ForeignScan
638 * within a worker. Most often, the answer will be no. For
639 * example, if the nature of the FDW is such that it opens a TCP
640 * connection with a remote server, each parallel worker would end
641 * up with a separate connection, and these connections might not
642 * be appropriately coordinated between workers and the leader.
643 */
644 if (rte->relkind == RELKIND_FOREIGN_TABLE)
645 {
646 Assert(rel->fdwroutine);
647 if (!rel->fdwroutine->IsForeignScanParallelSafe)
648 return;
649 if (!rel->fdwroutine->IsForeignScanParallelSafe(root, rel, rte))
650 return;
651 }
652
653 /*
654 * There are additional considerations for appendrels, which we'll
655 * deal with in set_append_rel_size and set_append_rel_pathlist.
656 * For now, just set consider_parallel based on the rel's own
657 * quals and targetlist.
658 */
659 break;
660
661 case RTE_SUBQUERY:
662
663 /*
664 * There's no intrinsic problem with scanning a subquery-in-FROM
665 * (as distinct from a SubPlan or InitPlan) in a parallel worker.
666 * If the subquery doesn't happen to have any parallel-safe paths,
667 * then flagging it as consider_parallel won't change anything,
668 * but that's true for plain tables, too. We must set
669 * consider_parallel based on the rel's own quals and targetlist,
670 * so that if a subquery path is parallel-safe but the quals and
671 * projection we're sticking onto it are not, we correctly mark
672 * the SubqueryScanPath as not parallel-safe. (Note that
673 * set_subquery_pathlist() might push some of these quals down
674 * into the subquery itself, but that doesn't change anything.)
675 *
676 * We can't push sub-select containing LIMIT/OFFSET to workers as
677 * there is no guarantee that the row order will be fully
678 * deterministic, and applying LIMIT/OFFSET will lead to
679 * inconsistent results at the top-level. (In some cases, where
680 * the result is ordered, we could relax this restriction. But it
681 * doesn't currently seem worth expending extra effort to do so.)
682 */
683 {
684 Query *subquery = castNode(Query, rte->subquery);
685
686 if (limit_needed(subquery))
687 return;
688 }
689 break;
690
691 case RTE_JOIN:
692 /* Shouldn't happen; we're only considering baserels here. */
693 Assert(false);
694 return;
695
696 case RTE_FUNCTION:
697 /* Check for parallel-restricted functions. */
698 if (!is_parallel_safe(root, (Node *) rte->functions))
699 return;
700 break;
701
702 case RTE_TABLEFUNC:
703 /* not parallel safe */
704 return;
705
706 case RTE_VALUES:
707 /* Check for parallel-restricted functions. */
708 if (!is_parallel_safe(root, (Node *) rte->values_lists))
709 return;
710 break;
711
712 case RTE_CTE:
713
714 /*
715 * CTE tuplestores aren't shared among parallel workers, so we
716 * force all CTE scans to happen in the leader. Also, populating
717 * the CTE would require executing a subplan that's not available
718 * in the worker, might be parallel-restricted, and must get
719 * executed only once.
720 */
721 return;
722
723 case RTE_NAMEDTUPLESTORE:
724
725 /*
726 * tuplestore cannot be shared, at least without more
727 * infrastructure to support that.
728 */
729 return;
730
731 case RTE_RESULT:
732 /* RESULT RTEs, in themselves, are no problem. */
733 break;
734 case RTE_GROUP:
735 /* Shouldn't happen; we're only considering baserels here. */
736 Assert(false);
737 return;
738 }
739
740 /*
741 * If there's anything in baserestrictinfo that's parallel-restricted, we
742 * give up on parallelizing access to this relation. We could consider
743 * instead postponing application of the restricted quals until we're
744 * above all the parallelism in the plan tree, but it's not clear that
745 * that would be a win in very many cases, and it might be tricky to make
746 * outer join clauses work correctly. It would likely break equivalence
747 * classes, too.
748 */
749 if (!is_parallel_safe(root, (Node *) rel->baserestrictinfo))
750 return;
751
752 /*
753 * Likewise, if the relation's outputs are not parallel-safe, give up.
754 * (Usually, they're just Vars, but sometimes they're not.)
755 */
756 if (!is_parallel_safe(root, (Node *) rel->reltarget->exprs))
757 return;
758
759 /* We have a winner. */
760 rel->consider_parallel = true;
761}
762
763/*
764 * set_plain_rel_pathlist
765 * Build access paths for a plain relation (no subquery, no inheritance)
766 */
767static void
768set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
769{
770 Relids required_outer;
771
772 /*
773 * We don't support pushing join clauses into the quals of a seqscan, but
774 * it could still have required parameterization due to LATERAL refs in
775 * its tlist.
776 */
777 required_outer = rel->lateral_relids;
778
779 /*
780 * Consider TID scans.
781 *
782 * If create_tidscan_paths returns true, then a TID scan path is forced.
783 * This happens when rel->baserestrictinfo contains CurrentOfExpr, because
784 * the executor can't handle any other type of path for such queries.
785 * Hence, we return without adding any other paths.
786 */
787 if (create_tidscan_paths(root, rel))
788 return;
789
790 /* Consider sequential scan */
791 add_path(rel, create_seqscan_path(root, rel, required_outer, 0));
792
793 /* If appropriate, consider parallel sequential scan */
794 if (rel->consider_parallel && required_outer == NULL)
795 create_plain_partial_paths(root, rel);
796
797 /* Consider index scans */
798 create_index_paths(root, rel);
799}
800
801/*
802 * create_plain_partial_paths
803 * Build partial access paths for parallel scan of a plain relation
804 */
805static void
806create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel)
807{
808 int parallel_workers;
809
810 parallel_workers = compute_parallel_worker(rel, rel->pages, -1,
811 max_parallel_workers_per_gather);
812
813 /* If any limit was set to zero, the user doesn't want a parallel scan. */
814 if (parallel_workers <= 0)
815 return;
816
817 /* Add an unordered partial path based on a parallel sequential scan. */
818 add_partial_path(rel, create_seqscan_path(root, rel, NULL, parallel_workers));
819}
820
821/*
822 * set_tablesample_rel_size
823 * Set size estimates for a sampled relation
824 */
825static void
826set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
827{
828 TableSampleClause *tsc = rte->tablesample;
829 TsmRoutine *tsm;
830 BlockNumber pages;
831 double tuples;
832
833 /*
834 * Test any partial indexes of rel for applicability. We must do this
835 * first since partial unique indexes can affect size estimates.
836 */
837 check_index_predicates(root, rel);
838
839 /*
840 * Call the sampling method's estimation function to estimate the number
841 * of pages it will read and the number of tuples it will return. (Note:
842 * we assume the function returns sane values.)
843 */
844 tsm = GetTsmRoutine(tsc->tsmhandler);
845 tsm->SampleScanGetSampleSize(root, rel, tsc->args,
846 &pages, &tuples);
847
848 /*
849 * For the moment, because we will only consider a SampleScan path for the
850 * rel, it's okay to just overwrite the pages and tuples estimates for the
851 * whole relation. If we ever consider multiple path types for sampled
852 * rels, we'll need more complication.
853 */
854 rel->pages = pages;
855 rel->tuples = tuples;
856
857 /* Mark rel with estimated output rows, width, etc */
858 set_baserel_size_estimates(root, rel);
859}
860
861/*
862 * set_tablesample_rel_pathlist
863 * Build access paths for a sampled relation
864 */
865static void
866set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
867{
868 Relids required_outer;
869 Path *path;
870
871 /*
872 * We don't support pushing join clauses into the quals of a samplescan,
873 * but it could still have required parameterization due to LATERAL refs
874 * in its tlist or TABLESAMPLE arguments.
875 */
876 required_outer = rel->lateral_relids;
877
878 /* Consider sampled scan */
879 path = create_samplescan_path(root, rel, required_outer);
880
881 /*
882 * If the sampling method does not support repeatable scans, we must avoid
883 * plans that would scan the rel multiple times. Ideally, we'd simply
884 * avoid putting the rel on the inside of a nestloop join; but adding such
885 * a consideration to the planner seems like a great deal of complication
886 * to support an uncommon usage of second-rate sampling methods. Instead,
887 * if there is a risk that the query might perform an unsafe join, just
888 * wrap the SampleScan in a Materialize node. We can check for joins by
889 * counting the membership of all_query_rels (note that this correctly
890 * counts inheritance trees as single rels). If we're inside a subquery,
891 * we can't easily check whether a join might occur in the outer query, so
892 * just assume one is possible.
893 *
894 * GetTsmRoutine is relatively expensive compared to the other tests here,
895 * so check repeatable_across_scans last, even though that's a bit odd.
896 */
897 if ((root->query_level > 1 ||
898 bms_membership(root->all_query_rels) != BMS_SINGLETON) &&
899 !(GetTsmRoutine(rte->tablesample->tsmhandler)->repeatable_across_scans))
900 {
901 path = (Path *) create_material_path(rel, path);
902 }
903
904 add_path(rel, path);
905
906 /* For the moment, at least, there are no other paths to consider */
907}
908
909/*
910 * set_foreign_size
911 * Set size estimates for a foreign table RTE
912 */
913static void
914set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
915{
916 /* Mark rel with estimated output rows, width, etc */
917 set_foreign_size_estimates(root, rel);
918
919 /* Let FDW adjust the size estimates, if it can */
920 rel->fdwroutine->GetForeignRelSize(root, rel, rte->relid);
921
922 /* ... but do not let it set the rows estimate to zero */
923 rel->rows = clamp_row_est(rel->rows);
924
925 /*
926 * Also, make sure rel->tuples is not insane relative to rel->rows.
927 * Notably, this ensures sanity if pg_class.reltuples contains -1 and the
928 * FDW doesn't do anything to replace that.
929 */
930 rel->tuples = Max(rel->tuples, rel->rows);
931}
932
933/*
934 * set_foreign_pathlist
935 * Build access paths for a foreign table RTE
936 */
937static void
938set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
939{
940 /* Call the FDW's GetForeignPaths function to generate path(s) */
941 rel->fdwroutine->GetForeignPaths(root, rel, rte->relid);
942}
943
944/*
945 * set_append_rel_size
946 * Set size estimates for a simple "append relation"
947 *
948 * The passed-in rel and RTE represent the entire append relation. The
949 * relation's contents are computed by appending together the output of the
950 * individual member relations. Note that in the non-partitioned inheritance
951 * case, the first member relation is actually the same table as is mentioned
952 * in the parent RTE ... but it has a different RTE and RelOptInfo. This is
953 * a good thing because their outputs are not the same size.
954 */
955static void
956set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
957 Index rti, RangeTblEntry *rte)
958{
959 int parentRTindex = rti;
960 bool has_live_children;
961 double parent_tuples;
962 double parent_rows;
963 double parent_size;
964 double *parent_attrsizes;
965 int nattrs;
966 ListCell *l;
967
968 /* Guard against stack overflow due to overly deep inheritance tree. */
969 check_stack_depth();
970
971 Assert(IS_SIMPLE_REL(rel));
972
973 /*
974 * If this is a partitioned baserel, set the consider_partitionwise_join
975 * flag; currently, we only consider partitionwise joins with the baserel
976 * if its targetlist doesn't contain a whole-row Var.
977 */
978 if (enable_partitionwise_join &&
979 rel->reloptkind == RELOPT_BASEREL &&
980 rte->relkind == RELKIND_PARTITIONED_TABLE &&
981 bms_is_empty(rel->attr_needed[InvalidAttrNumber - rel->min_attr]))
982 rel->consider_partitionwise_join = true;
983
984 /*
985 * Initialize to compute size estimates for whole append relation.
986 *
987 * We handle tuples estimates by setting "tuples" to the total number of
988 * tuples accumulated from each live child, rather than using "rows".
989 * Although an appendrel itself doesn't directly enforce any quals, its
990 * child relations may. Therefore, setting "tuples" equal to "rows" for
991 * an appendrel isn't always appropriate, and can lead to inaccurate cost
992 * estimates. For example, when estimating the number of distinct values
993 * from an appendrel, we would be unable to adjust the estimate based on
994 * the restriction selectivity (see estimate_num_groups).
995 *
996 * We handle width estimates by weighting the widths of different child
997 * rels proportionally to their number of rows. This is sensible because
998 * the use of width estimates is mainly to compute the total relation
999 * "footprint" if we have to sort or hash it. To do this, we sum the
1000 * total equivalent size (in "double" arithmetic) and then divide by the
1001 * total rowcount estimate. This is done separately for the total rel
1002 * width and each attribute.
1003 *
1004 * Note: if you consider changing this logic, beware that child rels could
1005 * have zero rows and/or width, if they were excluded by constraints.
1006 */
1007 has_live_children = false;
1008 parent_tuples = 0;
1009 parent_rows = 0;
1010 parent_size = 0;
1011 nattrs = rel->max_attr - rel->min_attr + 1;
1012 parent_attrsizes = (double *) palloc0(nattrs * sizeof(double));
1013
1014 foreach(l, root->append_rel_list)
1015 {
1016 AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
1017 int childRTindex;
1018 RangeTblEntry *childRTE;
1019 RelOptInfo *childrel;
1020 List *childrinfos;
1021 ListCell *parentvars;
1022 ListCell *childvars;
1023 ListCell *lc;
1024
1025 /* append_rel_list contains all append rels; ignore others */
1026 if (appinfo->parent_relid != parentRTindex)
1027 continue;
1028
1029 childRTindex = appinfo->child_relid;
1030 childRTE = root->simple_rte_array[childRTindex];
1031
1032 /*
1033 * The child rel's RelOptInfo was already created during
1034 * add_other_rels_to_query.
1035 */
1036 childrel = find_base_rel(root, childRTindex);
1037 Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL);
1038
1039 /* We may have already proven the child to be dummy. */
1040 if (IS_DUMMY_REL(childrel))
1041 continue;
1042
1043 /*
1044 * We have to copy the parent's targetlist and quals to the child,
1045 * with appropriate substitution of variables. However, the
1046 * baserestrictinfo quals were already copied/substituted when the
1047 * child RelOptInfo was built. So we don't need any additional setup
1048 * before applying constraint exclusion.
1049 */
1050 if (relation_excluded_by_constraints(root, childrel, childRTE))
1051 {
1052 /*
1053 * This child need not be scanned, so we can omit it from the
1054 * appendrel.
1055 */
1056 set_dummy_rel_pathlist(childrel);
1057 continue;
1058 }
1059
1060 /*
1061 * Constraint exclusion failed, so copy the parent's join quals and
1062 * targetlist to the child, with appropriate variable substitutions.
1063 *
1064 * We skip join quals that came from above outer joins that can null
1065 * this rel, since they would be of no value while generating paths
1066 * for the child. This saves some effort while processing the child
1067 * rel, and it also avoids an implementation restriction in
1068 * adjust_appendrel_attrs (it can't apply nullingrels to a non-Var).
1069 */
1070 childrinfos = NIL;
1071 foreach(lc, rel->joininfo)
1072 {
1073 RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
1074
1075 if (!bms_overlap(rinfo->clause_relids, rel->nulling_relids))
1076 childrinfos = lappend(childrinfos,
1077 adjust_appendrel_attrs(root,
1078 (Node *) rinfo,
1079 1, &appinfo));
1080 }
1081 childrel->joininfo = childrinfos;
1082
1083 /*
1084 * Now for the child's targetlist.
1085 *
1086 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
1087 * expressions, which otherwise would not occur in a rel's targetlist.
1088 * Code that might be looking at an appendrel child must cope with
1089 * such. (Normally, a rel's targetlist would only include Vars and
1090 * PlaceHolderVars.) XXX we do not bother to update the cost or width
1091 * fields of childrel->reltarget; not clear if that would be useful.
1092 */
1093 childrel->reltarget->exprs = (List *)
1094 adjust_appendrel_attrs(root,
1095 (Node *) rel->reltarget->exprs,
1096 1, &appinfo);
1097
1098 /*
1099 * We have to make child entries in the EquivalenceClass data
1100 * structures as well. This is needed either if the parent
1101 * participates in some eclass joins (because we will want to consider
1102 * inner-indexscan joins on the individual children) or if the parent
1103 * has useful pathkeys (because we should try to build MergeAppend
1104 * paths that produce those sort orderings).
1105 */
1106 if (rel->has_eclass_joins || has_useful_pathkeys(root, rel))
1107 add_child_rel_equivalences(root, appinfo, rel, childrel);
1108 childrel->has_eclass_joins = rel->has_eclass_joins;
1109
1110 /*
1111 * Note: we could compute appropriate attr_needed data for the child's
1112 * variables, by transforming the parent's attr_needed through the
1113 * translated_vars mapping. However, currently there's no need
1114 * because attr_needed is only examined for base relations not
1115 * otherrels. So we just leave the child's attr_needed empty.
1116 */
1117
1118 /*
1119 * If we consider partitionwise joins with the parent rel, do the same
1120 * for partitioned child rels.
1121 *
1122 * Note: here we abuse the consider_partitionwise_join flag by setting
1123 * it for child rels that are not themselves partitioned. We do so to
1124 * tell try_partitionwise_join() that the child rel is sufficiently
1125 * valid to be used as a per-partition input, even if it later gets
1126 * proven to be dummy. (It's not usable until we've set up the
1127 * reltarget and EC entries, which we just did.)
1128 */
1129 if (rel->consider_partitionwise_join)
1130 childrel->consider_partitionwise_join = true;
1131
1132 /*
1133 * If parallelism is allowable for this query in general, see whether
1134 * it's allowable for this childrel in particular. But if we've
1135 * already decided the appendrel is not parallel-safe as a whole,
1136 * there's no point in considering parallelism for this child. For
1137 * consistency, do this before calling set_rel_size() for the child.
1138 */
1139 if (root->glob->parallelModeOK && rel->consider_parallel)
1140 set_rel_consider_parallel(root, childrel, childRTE);
1141
1142 /*
1143 * Compute the child's size.
1144 */
1145 set_rel_size(root, childrel, childRTindex, childRTE);
1146
1147 /*
1148 * It is possible that constraint exclusion detected a contradiction
1149 * within a child subquery, even though we didn't prove one above. If
1150 * so, we can skip this child.
1151 */
1152 if (IS_DUMMY_REL(childrel))
1153 continue;
1154
1155 /* We have at least one live child. */
1156 has_live_children = true;
1157
1158 /*
1159 * If any live child is not parallel-safe, treat the whole appendrel
1160 * as not parallel-safe. In future we might be able to generate plans
1161 * in which some children are farmed out to workers while others are
1162 * not; but we don't have that today, so it's a waste to consider
1163 * partial paths anywhere in the appendrel unless it's all safe.
1164 * (Child rels visited before this one will be unmarked in
1165 * set_append_rel_pathlist().)
1166 */
1167 if (!childrel->consider_parallel)
1168 rel->consider_parallel = false;
1169
1170 /*
1171 * Accumulate size information from each live child.
1172 */
1173 Assert(childrel->rows > 0);
1174
1175 parent_tuples += childrel->tuples;
1176 parent_rows += childrel->rows;
1177 parent_size += childrel->reltarget->width * childrel->rows;
1178
1179 /*
1180 * Accumulate per-column estimates too. We need not do anything for
1181 * PlaceHolderVars in the parent list. If child expression isn't a
1182 * Var, or we didn't record a width estimate for it, we have to fall
1183 * back on a datatype-based estimate.
1184 *
1185 * By construction, child's targetlist is 1-to-1 with parent's.
1186 */
1187 forboth(parentvars, rel->reltarget->exprs,
1188 childvars, childrel->reltarget->exprs)
1189 {
1190 Var *parentvar = (Var *) lfirst(parentvars);
1191 Node *childvar = (Node *) lfirst(childvars);
1192
1193 if (IsA(parentvar, Var) && parentvar->varno == parentRTindex)
1194 {
1195 int pndx = parentvar->varattno - rel->min_attr;
1196 int32 child_width = 0;
1197
1198 if (IsA(childvar, Var) &&
1199 ((Var *) childvar)->varno == childrel->relid)
1200 {
1201 int cndx = ((Var *) childvar)->varattno - childrel->min_attr;
1202
1203 child_width = childrel->attr_widths[cndx];
1204 }
1205 if (child_width <= 0)
1206 child_width = get_typavgwidth(exprType(childvar),
1207 exprTypmod(childvar));
1208 Assert(child_width > 0);
1209 parent_attrsizes[pndx] += child_width * childrel->rows;
1210 }
1211 }
1212 }
1213
1214 if (has_live_children)
1215 {
1216 /*
1217 * Save the finished size estimates.
1218 */
1219 int i;
1220
1221 Assert(parent_rows > 0);
1222 rel->tuples = parent_tuples;
1223 rel->rows = parent_rows;
1224 rel->reltarget->width = rint(parent_size / parent_rows);
1225 for (i = 0; i < nattrs; i++)
1226 rel->attr_widths[i] = rint(parent_attrsizes[i] / parent_rows);
1227
1228 /*
1229 * Note that we leave rel->pages as zero; this is important to avoid
1230 * double-counting the appendrel tree in total_table_pages.
1231 */
1232 }
1233 else
1234 {
1235 /*
1236 * All children were excluded by constraints, so mark the whole
1237 * appendrel dummy. We must do this in this phase so that the rel's
1238 * dummy-ness is visible when we generate paths for other rels.
1239 */
1240 set_dummy_rel_pathlist(rel);
1241 }
1242
1243 pfree(parent_attrsizes);
1244}
1245
1246/*
1247 * set_append_rel_pathlist
1248 * Build access paths for an "append relation"
1249 */
1250static void
1251set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel,
1252 Index rti, RangeTblEntry *rte)
1253{
1254 int parentRTindex = rti;
1255 List *live_childrels = NIL;
1256 ListCell *l;
1257
1258 /*
1259 * Generate access paths for each member relation, and remember the
1260 * non-dummy children.
1261 */
1262 foreach(l, root->append_rel_list)
1263 {
1264 AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l);
1265 int childRTindex;
1266 RangeTblEntry *childRTE;
1267 RelOptInfo *childrel;
1268
1269 /* append_rel_list contains all append rels; ignore others */
1270 if (appinfo->parent_relid != parentRTindex)
1271 continue;
1272
1273 /* Re-locate the child RTE and RelOptInfo */
1274 childRTindex = appinfo->child_relid;
1275 childRTE = root->simple_rte_array[childRTindex];
1276 childrel = root->simple_rel_array[childRTindex];
1277
1278 /*
1279 * If set_append_rel_size() decided the parent appendrel was
1280 * parallel-unsafe at some point after visiting this child rel, we
1281 * need to propagate the unsafety marking down to the child, so that
1282 * we don't generate useless partial paths for it.
1283 */
1284 if (!rel->consider_parallel)
1285 childrel->consider_parallel = false;
1286
1287 /*
1288 * Compute the child's access paths.
1289 */
1290 set_rel_pathlist(root, childrel, childRTindex, childRTE);
1291
1292 /*
1293 * If child is dummy, ignore it.
1294 */
1295 if (IS_DUMMY_REL(childrel))
1296 continue;
1297
1298 /*
1299 * Child is live, so add it to the live_childrels list for use below.
1300 */
1301 live_childrels = lappend(live_childrels, childrel);
1302 }
1303
1304 /* Add paths to the append relation. */
1305 add_paths_to_append_rel(root, rel, live_childrels);
1306}
1307
1308
1309/*
1310 * add_paths_to_append_rel
1311 * Generate paths for the given append relation given the set of non-dummy
1312 * child rels.
1313 *
1314 * The function collects all parameterizations and orderings supported by the
1315 * non-dummy children. For every such parameterization or ordering, it creates
1316 * an append path collecting one path from each non-dummy child with given
1317 * parameterization or ordering. Similarly it collects partial paths from
1318 * non-dummy children to create partial append paths.
1319 */
1320void
1321add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel,
1322 List *live_childrels)
1323{
1324 List *subpaths = NIL;
1325 bool subpaths_valid = true;
1326 List *startup_subpaths = NIL;
1327 bool startup_subpaths_valid = true;
1328 List *partial_subpaths = NIL;
1329 List *pa_partial_subpaths = NIL;
1330 List *pa_nonpartial_subpaths = NIL;
1331 bool partial_subpaths_valid = true;
1332 bool pa_subpaths_valid;
1333 List *all_child_pathkeys = NIL;
1334 List *all_child_outers = NIL;
1335 ListCell *l;
1336 double partial_rows = -1;
1337
1338 /* If appropriate, consider parallel append */
1339 pa_subpaths_valid = enable_parallel_append && rel->consider_parallel;
1340
1341 /*
1342 * For every non-dummy child, remember the cheapest path. Also, identify
1343 * all pathkeys (orderings) and parameterizations (required_outer sets)
1344 * available for the non-dummy member relations.
1345 */
1346 foreach(l, live_childrels)
1347 {
1348 RelOptInfo *childrel = lfirst(l);
1349 ListCell *lcp;
1350 Path *cheapest_partial_path = NULL;
1351
1352 /*
1353 * If child has an unparameterized cheapest-total path, add that to
1354 * the unparameterized Append path we are constructing for the parent.
1355 * If not, there's no workable unparameterized path.
1356 *
1357 * With partitionwise aggregates, the child rel's pathlist may be
1358 * empty, so don't assume that a path exists here.
1359 */
1360 if (childrel->pathlist != NIL &&
1361 childrel->cheapest_total_path->param_info == NULL)
1362 accumulate_append_subpath(childrel->cheapest_total_path,
1363 &subpaths, NULL);
1364 else
1365 subpaths_valid = false;
1366
1367 /*
1368 * When the planner is considering cheap startup plans, we'll also
1369 * collect all the cheapest_startup_paths (if set) and build an
1370 * AppendPath containing those as subpaths.
1371 */
1372 if (rel->consider_startup && childrel->cheapest_startup_path != NULL)
1373 {
1374 Path *cheapest_path;
1375
1376 /*
1377 * With an indication of how many tuples the query should provide,
1378 * the optimizer tries to choose the path optimal for that
1379 * specific number of tuples.
1380 */
1381 if (root->tuple_fraction > 0.0)
1382 cheapest_path =
1383 get_cheapest_fractional_path(childrel,
1384 root->tuple_fraction);
1385 else
1386 cheapest_path = childrel->cheapest_startup_path;
1387
1388 /* cheapest_startup_path must not be a parameterized path. */
1389 Assert(cheapest_path->param_info == NULL);
1390 accumulate_append_subpath(cheapest_path,
1391 &startup_subpaths,
1392 NULL);
1393 }
1394 else
1395 startup_subpaths_valid = false;
1396
1397
1398 /* Same idea, but for a partial plan. */
1399 if (childrel->partial_pathlist != NIL)
1400 {
1401 cheapest_partial_path = linitial(childrel->partial_pathlist);
1402 accumulate_append_subpath(cheapest_partial_path,
1403 &partial_subpaths, NULL);
1404 }
1405 else
1406 partial_subpaths_valid = false;
1407
1408 /*
1409 * Same idea, but for a parallel append mixing partial and non-partial
1410 * paths.
1411 */
1412 if (pa_subpaths_valid)
1413 {
1414 Path *nppath = NULL;
1415
1416 nppath =
1417 get_cheapest_parallel_safe_total_inner(childrel->pathlist);
1418
1419 if (cheapest_partial_path == NULL && nppath == NULL)
1420 {
1421 /* Neither a partial nor a parallel-safe path? Forget it. */
1422 pa_subpaths_valid = false;
1423 }
1424 else if (nppath == NULL ||
1425 (cheapest_partial_path != NULL &&
1426 cheapest_partial_path->total_cost < nppath->total_cost))
1427 {
1428 /* Partial path is cheaper or the only option. */
1429 Assert(cheapest_partial_path != NULL);
1430 accumulate_append_subpath(cheapest_partial_path,
1431 &pa_partial_subpaths,
1432 &pa_nonpartial_subpaths);
1433 }
1434 else
1435 {
1436 /*
1437 * Either we've got only a non-partial path, or we think that
1438 * a single backend can execute the best non-partial path
1439 * faster than all the parallel backends working together can
1440 * execute the best partial path.
1441 *
1442 * It might make sense to be more aggressive here. Even if
1443 * the best non-partial path is more expensive than the best
1444 * partial path, it could still be better to choose the
1445 * non-partial path if there are several such paths that can
1446 * be given to different workers. For now, we don't try to
1447 * figure that out.
1448 */
1449 accumulate_append_subpath(nppath,
1450 &pa_nonpartial_subpaths,
1451 NULL);
1452 }
1453 }
1454
1455 /*
1456 * Collect lists of all the available path orderings and
1457 * parameterizations for all the children. We use these as a
1458 * heuristic to indicate which sort orderings and parameterizations we
1459 * should build Append and MergeAppend paths for.
1460 */
1461 foreach(lcp, childrel->pathlist)
1462 {
1463 Path *childpath = (Path *) lfirst(lcp);
1464 List *childkeys = childpath->pathkeys;
1465 Relids childouter = PATH_REQ_OUTER(childpath);
1466
1467 /* Unsorted paths don't contribute to pathkey list */
1468 if (childkeys != NIL)
1469 {
1470 ListCell *lpk;
1471 bool found = false;
1472
1473 /* Have we already seen this ordering? */
1474 foreach(lpk, all_child_pathkeys)
1475 {
1476 List *existing_pathkeys = (List *) lfirst(lpk);
1477
1478 if (compare_pathkeys(existing_pathkeys,
1479 childkeys) == PATHKEYS_EQUAL)
1480 {
1481 found = true;
1482 break;
1483 }
1484 }
1485 if (!found)
1486 {
1487 /* No, so add it to all_child_pathkeys */
1488 all_child_pathkeys = lappend(all_child_pathkeys,
1489 childkeys);
1490 }
1491 }
1492
1493 /* Unparameterized paths don't contribute to param-set list */
1494 if (childouter)
1495 {
1496 ListCell *lco;
1497 bool found = false;
1498
1499 /* Have we already seen this param set? */
1500 foreach(lco, all_child_outers)
1501 {
1502 Relids existing_outers = (Relids) lfirst(lco);
1503
1504 if (bms_equal(existing_outers, childouter))
1505 {
1506 found = true;
1507 break;
1508 }
1509 }
1510 if (!found)
1511 {
1512 /* No, so add it to all_child_outers */
1513 all_child_outers = lappend(all_child_outers,
1514 childouter);
1515 }
1516 }
1517 }
1518 }
1519
1520 /*
1521 * If we found unparameterized paths for all children, build an unordered,
1522 * unparameterized Append path for the rel. (Note: this is correct even
1523 * if we have zero or one live subpath due to constraint exclusion.)
1524 */
1525 if (subpaths_valid)
1526 add_path(rel, (Path *) create_append_path(root, rel, subpaths, NIL,
1527 NIL, NULL, 0, false,
1528 -1));
1529
1530 /* build an AppendPath for the cheap startup paths, if valid */
1531 if (startup_subpaths_valid)
1532 add_path(rel, (Path *) create_append_path(root, rel, startup_subpaths,
1533 NIL, NIL, NULL, 0, false, -1));
1534
1535 /*
1536 * Consider an append of unordered, unparameterized partial paths. Make
1537 * it parallel-aware if possible.
1538 */
1539 if (partial_subpaths_valid && partial_subpaths != NIL)
1540 {
1541 AppendPath *appendpath;
1542 ListCell *lc;
1543 int parallel_workers = 0;
1544
1545 /* Find the highest number of workers requested for any subpath. */
1546 foreach(lc, partial_subpaths)
1547 {
1548 Path *path = lfirst(lc);
1549
1550 parallel_workers = Max(parallel_workers, path->parallel_workers);
1551 }
1552 Assert(parallel_workers > 0);
1553
1554 /*
1555 * If the use of parallel append is permitted, always request at least
1556 * log2(# of children) workers. We assume it can be useful to have
1557 * extra workers in this case because they will be spread out across
1558 * the children. The precise formula is just a guess, but we don't
1559 * want to end up with a radically different answer for a table with N
1560 * partitions vs. an unpartitioned table with the same data, so the
1561 * use of some kind of log-scaling here seems to make some sense.
1562 */
1563 if (enable_parallel_append)
1564 {
1565 parallel_workers = Max(parallel_workers,
1566 pg_leftmost_one_pos32(list_length(live_childrels)) + 1);
1567 parallel_workers = Min(parallel_workers,
1568 max_parallel_workers_per_gather);
1569 }
1570 Assert(parallel_workers > 0);
1571
1572 /* Generate a partial append path. */
1573 appendpath = create_append_path(root, rel, NIL, partial_subpaths,
1574 NIL, NULL, parallel_workers,
1575 enable_parallel_append,
1576 -1);
1577
1578 /*
1579 * Make sure any subsequent partial paths use the same row count
1580 * estimate.
1581 */
1582 partial_rows = appendpath->path.rows;
1583
1584 /* Add the path. */
1585 add_partial_path(rel, (Path *) appendpath);
1586 }
1587
1588 /*
1589 * Consider a parallel-aware append using a mix of partial and non-partial
1590 * paths. (This only makes sense if there's at least one child which has
1591 * a non-partial path that is substantially cheaper than any partial path;
1592 * otherwise, we should use the append path added in the previous step.)
1593 */
1594 if (pa_subpaths_valid && pa_nonpartial_subpaths != NIL)
1595 {
1596 AppendPath *appendpath;
1597 ListCell *lc;
1598 int parallel_workers = 0;
1599
1600 /*
1601 * Find the highest number of workers requested for any partial
1602 * subpath.
1603 */
1604 foreach(lc, pa_partial_subpaths)
1605 {
1606 Path *path = lfirst(lc);
1607
1608 parallel_workers = Max(parallel_workers, path->parallel_workers);
1609 }
1610
1611 /*
1612 * Same formula here as above. It's even more important in this
1613 * instance because the non-partial paths won't contribute anything to
1614 * the planned number of parallel workers.
1615 */
1616 parallel_workers = Max(parallel_workers,
1617 pg_leftmost_one_pos32(list_length(live_childrels)) + 1);
1618 parallel_workers = Min(parallel_workers,
1619 max_parallel_workers_per_gather);
1620 Assert(parallel_workers > 0);
1621
1622 appendpath = create_append_path(root, rel, pa_nonpartial_subpaths,
1623 pa_partial_subpaths,
1624 NIL, NULL, parallel_workers, true,
1625 partial_rows);
1626 add_partial_path(rel, (Path *) appendpath);
1627 }
1628
1629 /*
1630 * Also build unparameterized ordered append paths based on the collected
1631 * list of child pathkeys.
1632 */
1633 if (subpaths_valid)
1634 generate_orderedappend_paths(root, rel, live_childrels,
1635 all_child_pathkeys);
1636
1637 /*
1638 * Build Append paths for each parameterization seen among the child rels.
1639 * (This may look pretty expensive, but in most cases of practical
1640 * interest, the child rels will expose mostly the same parameterizations,
1641 * so that not that many cases actually get considered here.)
1642 *
1643 * The Append node itself cannot enforce quals, so all qual checking must
1644 * be done in the child paths. This means that to have a parameterized
1645 * Append path, we must have the exact same parameterization for each
1646 * child path; otherwise some children might be failing to check the
1647 * moved-down quals. To make them match up, we can try to increase the
1648 * parameterization of lesser-parameterized paths.
1649 */
1650 foreach(l, all_child_outers)
1651 {
1652 Relids required_outer = (Relids) lfirst(l);
1653 ListCell *lcr;
1654
1655 /* Select the child paths for an Append with this parameterization */
1656 subpaths = NIL;
1657 subpaths_valid = true;
1658 foreach(lcr, live_childrels)
1659 {
1660 RelOptInfo *childrel = (RelOptInfo *) lfirst(lcr);
1661 Path *subpath;
1662
1663 if (childrel->pathlist == NIL)
1664 {
1665 /* failed to make a suitable path for this child */
1666 subpaths_valid = false;
1667 break;
1668 }
1669
1670 subpath = get_cheapest_parameterized_child_path(root,
1671 childrel,
1672 required_outer);
1673 if (subpath == NULL)
1674 {
1675 /* failed to make a suitable path for this child */
1676 subpaths_valid = false;
1677 break;
1678 }
1679 accumulate_append_subpath(subpath, &subpaths, NULL);
1680 }
1681
1682 if (subpaths_valid)
1683 add_path(rel, (Path *)
1684 create_append_path(root, rel, subpaths, NIL,
1685 NIL, required_outer, 0, false,
1686 -1));
1687 }
1688
1689 /*
1690 * When there is only a single child relation, the Append path can inherit
1691 * any ordering available for the child rel's path, so that it's useful to
1692 * consider ordered partial paths. Above we only considered the cheapest
1693 * partial path for each child, but let's also make paths using any
1694 * partial paths that have pathkeys.
1695 */
1696 if (list_length(live_childrels) == 1)
1697 {
1698 RelOptInfo *childrel = (RelOptInfo *) linitial(live_childrels);
1699
1700 /* skip the cheapest partial path, since we already used that above */
1701 for_each_from(l, childrel->partial_pathlist, 1)
1702 {
1703 Path *path = (Path *) lfirst(l);
1704 AppendPath *appendpath;
1705
1706 /* skip paths with no pathkeys. */
1707 if (path->pathkeys == NIL)
1708 continue;
1709
1710 appendpath = create_append_path(root, rel, NIL, list_make1(path),
1711 NIL, NULL,
1712 path->parallel_workers, true,
1713 partial_rows);
1714 add_partial_path(rel, (Path *) appendpath);
1715 }
1716 }
1717}
1718
1719/*
1720 * generate_orderedappend_paths
1721 * Generate ordered append paths for an append relation
1722 *
1723 * Usually we generate MergeAppend paths here, but there are some special
1724 * cases where we can generate simple Append paths, because the subpaths
1725 * can provide tuples in the required order already.
1726 *
1727 * We generate a path for each ordering (pathkey list) appearing in
1728 * all_child_pathkeys.
1729 *
1730 * We consider both cheapest-startup and cheapest-total cases, ie, for each
1731 * interesting ordering, collect all the cheapest startup subpaths and all the
1732 * cheapest total paths, and build a suitable path for each case.
1733 *
1734 * We don't currently generate any parameterized ordered paths here. While
1735 * it would not take much more code here to do so, it's very unclear that it
1736 * is worth the planning cycles to investigate such paths: there's little
1737 * use for an ordered path on the inside of a nestloop. In fact, it's likely
1738 * that the current coding of add_path would reject such paths out of hand,
1739 * because add_path gives no credit for sort ordering of parameterized paths,
1740 * and a parameterized MergeAppend is going to be more expensive than the
1741 * corresponding parameterized Append path. If we ever try harder to support
1742 * parameterized mergejoin plans, it might be worth adding support for
1743 * parameterized paths here to feed such joins. (See notes in
1744 * optimizer/README for why that might not ever happen, though.)
1745 */
1746static void
1747generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
1748 List *live_childrels,
1749 List *all_child_pathkeys)
1750{
1751 ListCell *lcp;
1752 List *partition_pathkeys = NIL;
1753 List *partition_pathkeys_desc = NIL;
1754 bool partition_pathkeys_partial = true;
1755 bool partition_pathkeys_desc_partial = true;
1756
1757 /*
1758 * Some partitioned table setups may allow us to use an Append node
1759 * instead of a MergeAppend. This is possible in cases such as RANGE
1760 * partitioned tables where it's guaranteed that an earlier partition must
1761 * contain rows which come earlier in the sort order. To detect whether
1762 * this is relevant, build pathkey descriptions of the partition ordering,
1763 * for both forward and reverse scans.
1764 */
1765 if (rel->part_scheme != NULL && IS_SIMPLE_REL(rel) &&
1766 partitions_are_ordered(rel->boundinfo, rel->live_parts))
1767 {
1768 partition_pathkeys = build_partition_pathkeys(root, rel,
1769 ForwardScanDirection,
1770 &partition_pathkeys_partial);
1771
1772 partition_pathkeys_desc = build_partition_pathkeys(root, rel,
1773 BackwardScanDirection,
1774 &partition_pathkeys_desc_partial);
1775
1776 /*
1777 * You might think we should truncate_useless_pathkeys here, but
1778 * allowing partition keys which are a subset of the query's pathkeys
1779 * can often be useful. For example, consider a table partitioned by
1780 * RANGE (a, b), and a query with ORDER BY a, b, c. If we have child
1781 * paths that can produce the a, b, c ordering (perhaps via indexes on
1782 * (a, b, c)) then it works to consider the appendrel output as
1783 * ordered by a, b, c.
1784 */
1785 }
1786
1787 /* Now consider each interesting sort ordering */
1788 foreach(lcp, all_child_pathkeys)
1789 {
1790 List *pathkeys = (List *) lfirst(lcp);
1791 List *startup_subpaths = NIL;
1792 List *total_subpaths = NIL;
1793 List *fractional_subpaths = NIL;
1794 bool startup_neq_total = false;
1795 bool match_partition_order;
1796 bool match_partition_order_desc;
1797 int end_index;
1798 int first_index;
1799 int direction;
1800
1801 /*
1802 * Determine if this sort ordering matches any partition pathkeys we
1803 * have, for both ascending and descending partition order. If the
1804 * partition pathkeys happen to be contained in pathkeys then it still
1805 * works, as described above, providing that the partition pathkeys
1806 * are complete and not just a prefix of the partition keys. (In such
1807 * cases we'll be relying on the child paths to have sorted the
1808 * lower-order columns of the required pathkeys.)
1809 */
1810 match_partition_order =
1811 pathkeys_contained_in(pathkeys, partition_pathkeys) ||
1812 (!partition_pathkeys_partial &&
1813 pathkeys_contained_in(partition_pathkeys, pathkeys));
1814
1815 match_partition_order_desc = !match_partition_order &&
1816 (pathkeys_contained_in(pathkeys, partition_pathkeys_desc) ||
1817 (!partition_pathkeys_desc_partial &&
1818 pathkeys_contained_in(partition_pathkeys_desc, pathkeys)));
1819
1820 /*
1821 * When the required pathkeys match the reverse of the partition
1822 * order, we must build the list of paths in reverse starting with the
1823 * last matching partition first. We can get away without making any
1824 * special cases for this in the loop below by just looping backward
1825 * over the child relations in this case.
1826 */
1827 if (match_partition_order_desc)
1828 {
1829 /* loop backward */
1830 first_index = list_length(live_childrels) - 1;
1831 end_index = -1;
1832 direction = -1;
1833
1834 /*
1835 * Set this to true to save us having to check for
1836 * match_partition_order_desc in the loop below.
1837 */
1838 match_partition_order = true;
1839 }
1840 else
1841 {
1842 /* for all other case, loop forward */
1843 first_index = 0;
1844 end_index = list_length(live_childrels);
1845 direction = 1;
1846 }
1847
1848 /* Select the child paths for this ordering... */
1849 for (int i = first_index; i != end_index; i += direction)
1850 {
1851 RelOptInfo *childrel = list_nth_node(RelOptInfo, live_childrels, i);
1852 Path *cheapest_startup,
1853 *cheapest_total,
1854 *cheapest_fractional = NULL;
1855
1856 /* Locate the right paths, if they are available. */
1857 cheapest_startup =
1858 get_cheapest_path_for_pathkeys(childrel->pathlist,
1859 pathkeys,
1860 NULL,
1861 STARTUP_COST,
1862 false);
1863 cheapest_total =
1864 get_cheapest_path_for_pathkeys(childrel->pathlist,
1865 pathkeys,
1866 NULL,
1867 TOTAL_COST,
1868 false);
1869
1870 /*
1871 * If we can't find any paths with the right order just use the
1872 * cheapest-total path; we'll have to sort it later.
1873 */
1874 if (cheapest_startup == NULL || cheapest_total == NULL)
1875 {
1876 cheapest_startup = cheapest_total =
1877 childrel->cheapest_total_path;
1878 /* Assert we do have an unparameterized path for this child */
1879 Assert(cheapest_total->param_info == NULL);
1880 }
1881
1882 /*
1883 * When building a fractional path, determine a cheapest
1884 * fractional path for each child relation too. Looking at startup
1885 * and total costs is not enough, because the cheapest fractional
1886 * path may be dominated by two separate paths (one for startup,
1887 * one for total).
1888 *
1889 * When needed (building fractional path), determine the cheapest
1890 * fractional path too.
1891 */
1892 if (root->tuple_fraction > 0)
1893 {
1894 double path_fraction = (1.0 / root->tuple_fraction);
1895
1896 cheapest_fractional =
1897 get_cheapest_fractional_path_for_pathkeys(childrel->pathlist,
1898 pathkeys,
1899 NULL,
1900 path_fraction);
1901
1902 /*
1903 * If we found no path with matching pathkeys, use the
1904 * cheapest total path instead.
1905 *
1906 * XXX We might consider partially sorted paths too (with an
1907 * incremental sort on top). But we'd have to build all the
1908 * incremental paths, do the costing etc.
1909 */
1910 if (!cheapest_fractional)
1911 cheapest_fractional = cheapest_total;
1912 }
1913
1914 /*
1915 * Notice whether we actually have different paths for the
1916 * "cheapest" and "total" cases; frequently there will be no point
1917 * in two create_merge_append_path() calls.
1918 */
1919 if (cheapest_startup != cheapest_total)
1920 startup_neq_total = true;
1921
1922 /*
1923 * Collect the appropriate child paths. The required logic varies
1924 * for the Append and MergeAppend cases.
1925 */
1926 if (match_partition_order)
1927 {
1928 /*
1929 * We're going to make a plain Append path. We don't need
1930 * most of what accumulate_append_subpath would do, but we do
1931 * want to cut out child Appends or MergeAppends if they have
1932 * just a single subpath (and hence aren't doing anything
1933 * useful).
1934 */
1935 cheapest_startup = get_singleton_append_subpath(cheapest_startup);
1936 cheapest_total = get_singleton_append_subpath(cheapest_total);
1937
1938 startup_subpaths = lappend(startup_subpaths, cheapest_startup);
1939 total_subpaths = lappend(total_subpaths, cheapest_total);
1940
1941 if (cheapest_fractional)
1942 {
1943 cheapest_fractional = get_singleton_append_subpath(cheapest_fractional);
1944 fractional_subpaths = lappend(fractional_subpaths, cheapest_fractional);
1945 }
1946 }
1947 else
1948 {
1949 /*
1950 * Otherwise, rely on accumulate_append_subpath to collect the
1951 * child paths for the MergeAppend.
1952 */
1953 accumulate_append_subpath(cheapest_startup,
1954 &startup_subpaths, NULL);
1955 accumulate_append_subpath(cheapest_total,
1956 &total_subpaths, NULL);
1957
1958 if (cheapest_fractional)
1959 accumulate_append_subpath(cheapest_fractional,
1960 &fractional_subpaths, NULL);
1961 }
1962 }
1963
1964 /* ... and build the Append or MergeAppend paths */
1965 if (match_partition_order)
1966 {
1967 /* We only need Append */
1968 add_path(rel, (Path *) create_append_path(root,
1969 rel,
1970 startup_subpaths,
1971 NIL,
1972 pathkeys,
1973 NULL,
1974 0,
1975 false,
1976 -1));
1977 if (startup_neq_total)
1978 add_path(rel, (Path *) create_append_path(root,
1979 rel,
1980 total_subpaths,
1981 NIL,
1982 pathkeys,
1983 NULL,
1984 0,
1985 false,
1986 -1));
1987
1988 if (fractional_subpaths)
1989 add_path(rel, (Path *) create_append_path(root,
1990 rel,
1991 fractional_subpaths,
1992 NIL,
1993 pathkeys,
1994 NULL,
1995 0,
1996 false,
1997 -1));
1998 }
1999 else
2000 {
2001 /* We need MergeAppend */
2002 add_path(rel, (Path *) create_merge_append_path(root,
2003 rel,
2004 startup_subpaths,
2005 pathkeys,
2006 NULL));
2007 if (startup_neq_total)
2008 add_path(rel, (Path *) create_merge_append_path(root,
2009 rel,
2010 total_subpaths,
2011 pathkeys,
2012 NULL));
2013
2014 if (fractional_subpaths)
2015 add_path(rel, (Path *) create_merge_append_path(root,
2016 rel,
2017 fractional_subpaths,
2018 pathkeys,
2019 NULL));
2020 }
2021 }
2022}
2023
2024/*
2025 * get_cheapest_parameterized_child_path
2026 * Get cheapest path for this relation that has exactly the requested
2027 * parameterization.
2028 *
2029 * Returns NULL if unable to create such a path.
2030 */
2031static Path *
2032get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel,
2033 Relids required_outer)
2034{
2035 Path *cheapest;
2036 ListCell *lc;
2037
2038 /*
2039 * Look up the cheapest existing path with no more than the needed
2040 * parameterization. If it has exactly the needed parameterization, we're
2041 * done.
2042 */
2043 cheapest = get_cheapest_path_for_pathkeys(rel->pathlist,
2044 NIL,
2045 required_outer,
2046 TOTAL_COST,
2047 false);
2048 Assert(cheapest != NULL);
2049 if (bms_equal(PATH_REQ_OUTER(cheapest), required_outer))
2050 return cheapest;
2051
2052 /*
2053 * Otherwise, we can "reparameterize" an existing path to match the given
2054 * parameterization, which effectively means pushing down additional
2055 * joinquals to be checked within the path's scan. However, some existing
2056 * paths might check the available joinquals already while others don't;
2057 * therefore, it's not clear which existing path will be cheapest after
2058 * reparameterization. We have to go through them all and find out.
2059 */
2060 cheapest = NULL;
2061 foreach(lc, rel->pathlist)
2062 {
2063 Path *path = (Path *) lfirst(lc);
2064
2065 /* Can't use it if it needs more than requested parameterization */
2066 if (!bms_is_subset(PATH_REQ_OUTER(path), required_outer))
2067 continue;
2068
2069 /*
2070 * Reparameterization can only increase the path's cost, so if it's
2071 * already more expensive than the current cheapest, forget it.
2072 */
2073 if (cheapest != NULL &&
2074 compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
2075 continue;
2076
2077 /* Reparameterize if needed, then recheck cost */
2078 if (!bms_equal(PATH_REQ_OUTER(path), required_outer))
2079 {
2080 path = reparameterize_path(root, path, required_outer, 1.0);
2081 if (path == NULL)
2082 continue; /* failed to reparameterize this one */
2083 Assert(bms_equal(PATH_REQ_OUTER(path), required_outer));
2084
2085 if (cheapest != NULL &&
2086 compare_path_costs(cheapest, path, TOTAL_COST) <= 0)
2087 continue;
2088 }
2089
2090 /* We have a new best path */
2091 cheapest = path;
2092 }
2093
2094 /* Return the best path, or NULL if we found no suitable candidate */
2095 return cheapest;
2096}
2097
2098/*
2099 * accumulate_append_subpath
2100 * Add a subpath to the list being built for an Append or MergeAppend.
2101 *
2102 * It's possible that the child is itself an Append or MergeAppend path, in
2103 * which case we can "cut out the middleman" and just add its child paths to
2104 * our own list. (We don't try to do this earlier because we need to apply
2105 * both levels of transformation to the quals.)
2106 *
2107 * Note that if we omit a child MergeAppend in this way, we are effectively
2108 * omitting a sort step, which seems fine: if the parent is to be an Append,
2109 * its result would be unsorted anyway, while if the parent is to be a
2110 * MergeAppend, there's no point in a separate sort on a child.
2111 *
2112 * Normally, either path is a partial path and subpaths is a list of partial
2113 * paths, or else path is a non-partial plan and subpaths is a list of those.
2114 * However, if path is a parallel-aware Append, then we add its partial path
2115 * children to subpaths and the rest to special_subpaths. If the latter is
2116 * NULL, we don't flatten the path at all (unless it contains only partial
2117 * paths).
2118 */
2119static void
2120accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
2121{
2122 if (IsA(path, AppendPath))
2123 {
2124 AppendPath *apath = (AppendPath *) path;
2125
2126 if (!apath->path.parallel_aware || apath->first_partial_path == 0)
2127 {
2128 *subpaths = list_concat(*subpaths, apath->subpaths);
2129 return;
2130 }
2131 else if (special_subpaths != NULL)
2132 {
2133 List *new_special_subpaths;
2134
2135 /* Split Parallel Append into partial and non-partial subpaths */
2136 *subpaths = list_concat(*subpaths,
2137 list_copy_tail(apath->subpaths,
2138 apath->first_partial_path));
2139 new_special_subpaths = list_copy_head(apath->subpaths,
2140 apath->first_partial_path);
2141 *special_subpaths = list_concat(*special_subpaths,
2142 new_special_subpaths);
2143 return;
2144 }
2145 }
2146 else if (IsA(path, MergeAppendPath))
2147 {
2148 MergeAppendPath *mpath = (MergeAppendPath *) path;
2149
2150 *subpaths = list_concat(*subpaths, mpath->subpaths);
2151 return;
2152 }
2153
2154 *subpaths = lappend(*subpaths, path);
2155}
2156
2157/*
2158 * get_singleton_append_subpath
2159 * Returns the single subpath of an Append/MergeAppend, or just
2160 * return 'path' if it's not a single sub-path Append/MergeAppend.
2161 *
2162 * Note: 'path' must not be a parallel-aware path.
2163 */
2164static Path *
2165get_singleton_append_subpath(Path *path)
2166{
2167 Assert(!path->parallel_aware);
2168
2169 if (IsA(path, AppendPath))
2170 {
2171 AppendPath *apath = (AppendPath *) path;
2172
2173 if (list_length(apath->subpaths) == 1)
2174 return (Path *) linitial(apath->subpaths);
2175 }
2176 else if (IsA(path, MergeAppendPath))
2177 {
2178 MergeAppendPath *mpath = (MergeAppendPath *) path;
2179
2180 if (list_length(mpath->subpaths) == 1)
2181 return (Path *) linitial(mpath->subpaths);
2182 }
2183
2184 return path;
2185}
2186
2187/*
2188 * set_dummy_rel_pathlist
2189 * Build a dummy path for a relation that's been excluded by constraints
2190 *
2191 * Rather than inventing a special "dummy" path type, we represent this as an
2192 * AppendPath with no members (see also IS_DUMMY_APPEND/IS_DUMMY_REL macros).
2193 *
2194 * (See also mark_dummy_rel, which does basically the same thing, but is
2195 * typically used to change a rel into dummy state after we already made
2196 * paths for it.)
2197 */
2198static void
2199set_dummy_rel_pathlist(RelOptInfo *rel)
2200{
2201 /* Set dummy size estimates --- we leave attr_widths[] as zeroes */
2202 rel->rows = 0;
2203 rel->reltarget->width = 0;
2204
2205 /* Discard any pre-existing paths; no further need for them */
2206 rel->pathlist = NIL;
2207 rel->partial_pathlist = NIL;
2208
2209 /* Set up the dummy path */
2210 add_path(rel, (Path *) create_append_path(NULL, rel, NIL, NIL,
2211 NIL, rel->lateral_relids,
2212 0, false, -1));
2213
2214 /*
2215 * We set the cheapest-path fields immediately, just in case they were
2216 * pointing at some discarded path. This is redundant in current usage
2217 * because set_rel_pathlist will do it later, but it's cheap so we keep it
2218 * for safety and consistency with mark_dummy_rel.
2219 */
2220 set_cheapest(rel);
2221}
2222
2223/*
2224 * find_window_run_conditions
2225 * Determine if 'wfunc' is really a WindowFunc and call its prosupport
2226 * function to determine the function's monotonic properties. We then
2227 * see if 'opexpr' can be used to short-circuit execution.
2228 *
2229 * For example row_number() over (order by ...) always produces a value one
2230 * higher than the previous. If someone has a window function in a subquery
2231 * and has a WHERE clause in the outer query to filter rows <= 10, then we may
2232 * as well stop processing the windowagg once the row number reaches 11. Here
2233 * we check if 'opexpr' might help us to stop doing needless extra processing
2234 * in WindowAgg nodes.
2235 *
2236 * '*keep_original' is set to true if the caller should also use 'opexpr' for
2237 * its original purpose. This is set to false if the caller can assume that
2238 * the run condition will handle all of the required filtering.
2239 *
2240 * Returns true if 'opexpr' was found to be useful and was added to the
2241 * WindowFunc's runCondition. We also set *keep_original accordingly and add
2242 * 'attno' to *run_cond_attrs offset by FirstLowInvalidHeapAttributeNumber.
2243 * If the 'opexpr' cannot be used then we set *keep_original to true and
2244 * return false.
2245 */
2246static bool
2247find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti,
2248 AttrNumber attno, WindowFunc *wfunc, OpExpr *opexpr,
2249 bool wfunc_left, bool *keep_original,
2250 Bitmapset **run_cond_attrs)
2251{
2252 Oid prosupport;
2253 Expr *otherexpr;
2254 SupportRequestWFuncMonotonic req;
2255 SupportRequestWFuncMonotonic *res;
2256 WindowClause *wclause;
2257 List *opinfos;
2258 OpExpr *runopexpr;
2259 Oid runoperator;
2260 ListCell *lc;
2261
2262 *keep_original = true;
2263
2264 while (IsA(wfunc, RelabelType))
2265 wfunc = (WindowFunc *) ((RelabelType *) wfunc)->arg;
2266
2267 /* we can only work with window functions */
2268 if (!IsA(wfunc, WindowFunc))
2269 return false;
2270
2271 /* can't use it if there are subplans in the WindowFunc */
2272 if (contain_subplans((Node *) wfunc))
2273 return false;
2274
2275 prosupport = get_func_support(wfunc->winfnoid);
2276
2277 /* Check if there's a support function for 'wfunc' */
2278 if (!OidIsValid(prosupport))
2279 return false;
2280
2281 /* get the Expr from the other side of the OpExpr */
2282 if (wfunc_left)
2283 otherexpr = lsecond(opexpr->args);
2284 else
2285 otherexpr = linitial(opexpr->args);
2286
2287 /*
2288 * The value being compared must not change during the evaluation of the
2289 * window partition.
2290 */
2291 if (!is_pseudo_constant_clause((Node *) otherexpr))
2292 return false;
2293
2294 /* find the window clause belonging to the window function */
2295 wclause = (WindowClause *) list_nth(subquery->windowClause,
2296 wfunc->winref - 1);
2297
2298 req.type = T_SupportRequestWFuncMonotonic;
2299 req.window_func = wfunc;
2300 req.window_clause = wclause;
2301
2302 /* call the support function */
2303 res = (SupportRequestWFuncMonotonic *)
2304 DatumGetPointer(OidFunctionCall1(prosupport,
2305 PointerGetDatum(&req)));
2306
2307 /*
2308 * Nothing to do if the function is neither monotonically increasing nor
2309 * monotonically decreasing.
2310 */
2311 if (res == NULL || res->monotonic == MONOTONICFUNC_NONE)
2312 return false;
2313
2314 runopexpr = NULL;
2315 runoperator = InvalidOid;
2316 opinfos = get_op_btree_interpretation(opexpr->opno);
2317
2318 foreach(lc, opinfos)
2319 {
2320 OpBtreeInterpretation *opinfo = (OpBtreeInterpretation *) lfirst(lc);
2321 int strategy = opinfo->strategy;
2322
2323 /* handle < / <= */
2324 if (strategy == BTLessStrategyNumber ||
2325 strategy == BTLessEqualStrategyNumber)
2326 {
2327 /*
2328 * < / <= is supported for monotonically increasing functions in
2329 * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
2330 * for monotonically decreasing functions.
2331 */
2332 if ((wfunc_left && (res->monotonic & MONOTONICFUNC_INCREASING)) ||
2333 (!wfunc_left && (res->monotonic & MONOTONICFUNC_DECREASING)))
2334 {
2335 *keep_original = false;
2336 runopexpr = opexpr;
2337 runoperator = opexpr->opno;
2338 }
2339 break;
2340 }
2341 /* handle > / >= */
2342 else if (strategy == BTGreaterStrategyNumber ||
2343 strategy == BTGreaterEqualStrategyNumber)
2344 {
2345 /*
2346 * > / >= is supported for monotonically decreasing functions in
2347 * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
2348 * for monotonically increasing functions.
2349 */
2350 if ((wfunc_left && (res->monotonic & MONOTONICFUNC_DECREASING)) ||
2351 (!wfunc_left && (res->monotonic & MONOTONICFUNC_INCREASING)))
2352 {
2353 *keep_original = false;
2354 runopexpr = opexpr;
2355 runoperator = opexpr->opno;
2356 }
2357 break;
2358 }
2359 /* handle = */
2360 else if (strategy == BTEqualStrategyNumber)
2361 {
2362 int16 newstrategy;
2363
2364 /*
2365 * When both monotonically increasing and decreasing then the
2366 * return value of the window function will be the same each time.
2367 * We can simply use 'opexpr' as the run condition without
2368 * modifying it.
2369 */
2370 if ((res->monotonic & MONOTONICFUNC_BOTH) == MONOTONICFUNC_BOTH)
2371 {
2372 *keep_original = false;
2373 runopexpr = opexpr;
2374 runoperator = opexpr->opno;
2375 break;
2376 }
2377
2378 /*
2379 * When monotonically increasing we make a qual with <wfunc> <=
2380 * <value> or <value> >= <wfunc> in order to filter out values
2381 * which are above the value in the equality condition. For
2382 * monotonically decreasing functions we want to filter values
2383 * below the value in the equality condition.
2384 */
2385 if (res->monotonic & MONOTONICFUNC_INCREASING)
2386 newstrategy = wfunc_left ? BTLessEqualStrategyNumber : BTGreaterEqualStrategyNumber;
2387 else
2388 newstrategy = wfunc_left ? BTGreaterEqualStrategyNumber : BTLessEqualStrategyNumber;
2389
2390 /* We must keep the original equality qual */
2391 *keep_original = true;
2392 runopexpr = opexpr;
2393
2394 /* determine the operator to use for the WindowFuncRunCondition */
2395 runoperator = get_opfamily_member(opinfo->opfamily_id,
2396 opinfo->oplefttype,
2397 opinfo->oprighttype,
2398 newstrategy);
2399 break;
2400 }
2401 }
2402
2403 if (runopexpr != NULL)
2404 {
2405 WindowFuncRunCondition *wfuncrc;
2406
2407 wfuncrc = makeNode(WindowFuncRunCondition);
2408 wfuncrc->opno = runoperator;
2409 wfuncrc->inputcollid = runopexpr->inputcollid;
2410 wfuncrc->wfunc_left = wfunc_left;
2411 wfuncrc->arg = copyObject(otherexpr);
2412
2413 wfunc->runCondition = lappend(wfunc->runCondition, wfuncrc);
2414
2415 /* record that this attno was used in a run condition */
2416 *run_cond_attrs = bms_add_member(*run_cond_attrs,
2417 attno - FirstLowInvalidHeapAttributeNumber);
2418 return true;
2419 }
2420
2421 /* unsupported OpExpr */
2422 return false;
2423}
2424
2425/*
2426 * check_and_push_window_quals
2427 * Check if 'clause' is a qual that can be pushed into a WindowFunc
2428 * as a 'runCondition' qual. These, when present, allow some unnecessary
2429 * work to be skipped during execution.
2430 *
2431 * 'run_cond_attrs' will be populated with all targetlist resnos of subquery
2432 * targets (offset by FirstLowInvalidHeapAttributeNumber) that we pushed
2433 * window quals for.
2434 *
2435 * Returns true if the caller still must keep the original qual or false if
2436 * the caller can safely ignore the original qual because the WindowAgg node
2437 * will use the runCondition to stop returning tuples.
2438 */
2439static bool
2440check_and_push_window_quals(Query *subquery, RangeTblEntry *rte, Index rti,
2441 Node *clause, Bitmapset **run_cond_attrs)
2442{
2443 OpExpr *opexpr = (OpExpr *) clause;
2444 bool keep_original = true;
2445 Var *var1;
2446 Var *var2;
2447
2448 /* We're only able to use OpExprs with 2 operands */
2449 if (!IsA(opexpr, OpExpr))
2450 return true;
2451
2452 if (list_length(opexpr->args) != 2)
2453 return true;
2454
2455 /*
2456 * Currently, we restrict this optimization to strict OpExprs. The reason
2457 * for this is that during execution, once the runcondition becomes false,
2458 * we stop evaluating WindowFuncs. To avoid leaving around stale window
2459 * function result values, we set them to NULL. Having only strict
2460 * OpExprs here ensures that we properly filter out the tuples with NULLs
2461 * in the top-level WindowAgg.
2462 */
2463 set_opfuncid(opexpr);
2464 if (!func_strict(opexpr->opfuncid))
2465 return true;
2466
2467 /*
2468 * Check for plain Vars that reference window functions in the subquery.
2469 * If we find any, we'll ask find_window_run_conditions() if 'opexpr' can
2470 * be used as part of the run condition.
2471 */
2472
2473 /* Check the left side of the OpExpr */
2474 var1 = linitial(opexpr->args);
2475 if (IsA(var1, Var) && var1->varattno > 0)
2476 {
2477 TargetEntry *tle = list_nth(subquery->targetList, var1->varattno - 1);
2478 WindowFunc *wfunc = (WindowFunc *) tle->expr;
2479
2480 if (find_window_run_conditions(subquery, rte, rti, tle->resno, wfunc,
2481 opexpr, true, &keep_original,
2482 run_cond_attrs))
2483 return keep_original;
2484 }
2485
2486 /* and check the right side */
2487 var2 = lsecond(opexpr->args);
2488 if (IsA(var2, Var) && var2->varattno > 0)
2489 {
2490 TargetEntry *tle = list_nth(subquery->targetList, var2->varattno - 1);
2491 WindowFunc *wfunc = (WindowFunc *) tle->expr;
2492
2493 if (find_window_run_conditions(subquery, rte, rti, tle->resno, wfunc,
2494 opexpr, false, &keep_original,
2495 run_cond_attrs))
2496 return keep_original;
2497 }
2498
2499 return true;
2500}
2501
2502/*
2503 * set_subquery_pathlist
2504 * Generate SubqueryScan access paths for a subquery RTE
2505 *
2506 * We don't currently support generating parameterized paths for subqueries
2507 * by pushing join clauses down into them; it seems too expensive to re-plan
2508 * the subquery multiple times to consider different alternatives.
2509 * (XXX that could stand to be reconsidered, now that we use Paths.)
2510 * So the paths made here will be parameterized if the subquery contains
2511 * LATERAL references, otherwise not. As long as that's true, there's no need
2512 * for a separate set_subquery_size phase: just make the paths right away.
2513 */
2514static void
2515set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel,
2516 Index rti, RangeTblEntry *rte)
2517{
2518 Query *parse = root->parse;
2519 Query *subquery = rte->subquery;
2520 bool trivial_pathtarget;
2521 Relids required_outer;
2522 pushdown_safety_info safetyInfo;
2523 double tuple_fraction;
2524 RelOptInfo *sub_final_rel;
2525 Bitmapset *run_cond_attrs = NULL;
2526 ListCell *lc;
2527
2528 /*
2529 * Must copy the Query so that planning doesn't mess up the RTE contents
2530 * (really really need to fix the planner to not scribble on its input,
2531 * someday ... but see remove_unused_subquery_outputs to start with).
2532 */
2533 subquery = copyObject(subquery);
2534
2535 /*
2536 * If it's a LATERAL subquery, it might contain some Vars of the current
2537 * query level, requiring it to be treated as parameterized, even though
2538 * we don't support pushing down join quals into subqueries.
2539 */
2540 required_outer = rel->lateral_relids;
2541
2542 /*
2543 * Zero out result area for subquery_is_pushdown_safe, so that it can set
2544 * flags as needed while recursing. In particular, we need a workspace
2545 * for keeping track of the reasons why columns are unsafe to reference.
2546 * These reasons are stored in the bits inside unsafeFlags[i] when we
2547 * discover reasons that column i of the subquery is unsafe to be used in
2548 * a pushed-down qual.
2549 */
2550 memset(&safetyInfo, 0, sizeof(safetyInfo));
2551 safetyInfo.unsafeFlags = (unsigned char *)
2552 palloc0((list_length(subquery->targetList) + 1) * sizeof(unsigned char));
2553
2554 /*
2555 * If the subquery has the "security_barrier" flag, it means the subquery
2556 * originated from a view that must enforce row-level security. Then we
2557 * must not push down quals that contain leaky functions. (Ideally this
2558 * would be checked inside subquery_is_pushdown_safe, but since we don't
2559 * currently pass the RTE to that function, we must do it here.)
2560 */
2561 safetyInfo.unsafeLeaky = rte->security_barrier;
2562
2563 /*
2564 * If there are any restriction clauses that have been attached to the
2565 * subquery relation, consider pushing them down to become WHERE or HAVING
2566 * quals of the subquery itself. This transformation is useful because it
2567 * may allow us to generate a better plan for the subquery than evaluating
2568 * all the subquery output rows and then filtering them.
2569 *
2570 * There are several cases where we cannot push down clauses. Restrictions
2571 * involving the subquery are checked by subquery_is_pushdown_safe().
2572 * Restrictions on individual clauses are checked by
2573 * qual_is_pushdown_safe(). Also, we don't want to push down
2574 * pseudoconstant clauses; better to have the gating node above the
2575 * subquery.
2576 *
2577 * Non-pushed-down clauses will get evaluated as qpquals of the
2578 * SubqueryScan node.
2579 *
2580 * XXX Are there any cases where we want to make a policy decision not to
2581 * push down a pushable qual, because it'd result in a worse plan?
2582 */
2583 if (rel->baserestrictinfo != NIL &&
2584 subquery_is_pushdown_safe(subquery, subquery, &safetyInfo))
2585 {
2586 /* OK to consider pushing down individual quals */
2587 List *upperrestrictlist = NIL;
2588 ListCell *l;
2589
2590 foreach(l, rel->baserestrictinfo)
2591 {
2592 RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);
2593 Node *clause = (Node *) rinfo->clause;
2594
2595 if (rinfo->pseudoconstant)
2596 {
2597 upperrestrictlist = lappend(upperrestrictlist, rinfo);
2598 continue;
2599 }
2600
2601 switch (qual_is_pushdown_safe(subquery, rti, rinfo, &safetyInfo))
2602 {
2603 case PUSHDOWN_SAFE:
2604 /* Push it down */
2605 subquery_push_qual(subquery, rte, rti, clause);
2606 break;
2607
2608 case PUSHDOWN_WINDOWCLAUSE_RUNCOND:
2609
2610 /*
2611 * Since we can't push the qual down into the subquery,
2612 * check if it happens to reference a window function. If
2613 * so then it might be useful to use for the WindowAgg's
2614 * runCondition.
2615 */
2616 if (!subquery->hasWindowFuncs ||
2617 check_and_push_window_quals(subquery, rte, rti, clause,
2618 &run_cond_attrs))
2619 {
2620 /*
2621 * subquery has no window funcs or the clause is not a
2622 * suitable window run condition qual or it is, but
2623 * the original must also be kept in the upper query.
2624 */
2625 upperrestrictlist = lappend(upperrestrictlist, rinfo);
2626 }
2627 break;
2628
2629 case PUSHDOWN_UNSAFE:
2630 upperrestrictlist = lappend(upperrestrictlist, rinfo);
2631 break;
2632 }
2633 }
2634 rel->baserestrictinfo = upperrestrictlist;
2635 /* We don't bother recomputing baserestrict_min_security */
2636 }
2637
2638 pfree(safetyInfo.unsafeFlags);
2639
2640 /*
2641 * The upper query might not use all the subquery's output columns; if
2642 * not, we can simplify. Pass the attributes that were pushed down into
2643 * WindowAgg run conditions to ensure we don't accidentally think those
2644 * are unused.
2645 */
2646 remove_unused_subquery_outputs(subquery, rel, run_cond_attrs);
2647
2648 /*
2649 * We can safely pass the outer tuple_fraction down to the subquery if the
2650 * outer level has no joining, aggregation, or sorting to do. Otherwise
2651 * we'd better tell the subquery to plan for full retrieval. (XXX This
2652 * could probably be made more intelligent ...)
2653 */
2654 if (parse->hasAggs ||
2655 parse->groupClause ||
2656 parse->groupingSets ||
2657 root->hasHavingQual ||
2658 parse->distinctClause ||
2659 parse->sortClause ||
2660 bms_membership(root->all_baserels) == BMS_MULTIPLE)
2661 tuple_fraction = 0.0; /* default case */
2662 else
2663 tuple_fraction = root->tuple_fraction;
2664
2665 /* plan_params should not be in use in current query level */
2666 Assert(root->plan_params == NIL);
2667
2668 /* Generate a subroot and Paths for the subquery */
2669 rel->subroot = subquery_planner(root->glob, subquery, root, false,
2670 tuple_fraction, NULL);
2671
2672 /* Isolate the params needed by this specific subplan */
2673 rel->subplan_params = root->plan_params;
2674 root->plan_params = NIL;
2675
2676 /*
2677 * It's possible that constraint exclusion proved the subquery empty. If
2678 * so, it's desirable to produce an unadorned dummy path so that we will
2679 * recognize appropriate optimizations at this query level.
2680 */
2681 sub_final_rel = fetch_upper_rel(rel->subroot, UPPERREL_FINAL, NULL);
2682
2683 if (IS_DUMMY_REL(sub_final_rel))
2684 {
2685 set_dummy_rel_pathlist(rel);
2686 return;
2687 }
2688
2689 /*
2690 * Mark rel with estimated output rows, width, etc. Note that we have to
2691 * do this before generating outer-query paths, else cost_subqueryscan is
2692 * not happy.
2693 */
2694 set_subquery_size_estimates(root, rel);
2695
2696 /*
2697 * Also detect whether the reltarget is trivial, so that we can pass that
2698 * info to cost_subqueryscan (rather than re-deriving it multiple times).
2699 * It's trivial if it fetches all the subplan output columns in order.
2700 */
2701 if (list_length(rel->reltarget->exprs) != list_length(subquery->targetList))
2702 trivial_pathtarget = false;
2703 else
2704 {
2705 trivial_pathtarget = true;
2706 foreach(lc, rel->reltarget->exprs)
2707 {
2708 Node *node = (Node *) lfirst(lc);
2709 Var *var;
2710
2711 if (!IsA(node, Var))
2712 {
2713 trivial_pathtarget = false;
2714 break;
2715 }
2716 var = (Var *) node;
2717 if (var->varno != rti ||
2718 var->varattno != foreach_current_index(lc) + 1)
2719 {
2720 trivial_pathtarget = false;
2721 break;
2722 }
2723 }
2724 }
2725
2726 /*
2727 * For each Path that subquery_planner produced, make a SubqueryScanPath
2728 * in the outer query.
2729 */
2730 foreach(lc, sub_final_rel->pathlist)
2731 {
2732 Path *subpath = (Path *) lfirst(lc);
2733 List *pathkeys;
2734
2735 /* Convert subpath's pathkeys to outer representation */
2736 pathkeys = convert_subquery_pathkeys(root,
2737 rel,
2738 subpath->pathkeys,
2739 make_tlist_from_pathtarget(subpath->pathtarget));
2740
2741 /* Generate outer path using this subpath */
2742 add_path(rel, (Path *)
2743 create_subqueryscan_path(root, rel, subpath,
2744 trivial_pathtarget,
2745 pathkeys, required_outer));
2746 }
2747
2748 /* If outer rel allows parallelism, do same for partial paths. */
2749 if (rel->consider_parallel && bms_is_empty(required_outer))
2750 {
2751 /* If consider_parallel is false, there should be no partial paths. */
2752 Assert(sub_final_rel->consider_parallel ||
2753 sub_final_rel->partial_pathlist == NIL);
2754
2755 /* Same for partial paths. */
2756 foreach(lc, sub_final_rel->partial_pathlist)
2757 {
2758 Path *subpath = (Path *) lfirst(lc);
2759 List *pathkeys;
2760
2761 /* Convert subpath's pathkeys to outer representation */
2762 pathkeys = convert_subquery_pathkeys(root,
2763 rel,
2764 subpath->pathkeys,
2765 make_tlist_from_pathtarget(subpath->pathtarget));
2766
2767 /* Generate outer path using this subpath */
2768 add_partial_path(rel, (Path *)
2769 create_subqueryscan_path(root, rel, subpath,
2770 trivial_pathtarget,
2771 pathkeys,
2772 required_outer));
2773 }
2774 }
2775}
2776
2777/*
2778 * set_function_pathlist
2779 * Build the (single) access path for a function RTE
2780 */
2781static void
2782set_function_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
2783{
2784 Relids required_outer;
2785 List *pathkeys = NIL;
2786
2787 /*
2788 * We don't support pushing join clauses into the quals of a function
2789 * scan, but it could still have required parameterization due to LATERAL
2790 * refs in the function expression.
2791 */
2792 required_outer = rel->lateral_relids;
2793
2794 /*
2795 * The result is considered unordered unless ORDINALITY was used, in which
2796 * case it is ordered by the ordinal column (the last one). See if we
2797 * care, by checking for uses of that Var in equivalence classes.
2798 */
2799 if (rte->funcordinality)
2800 {
2801 AttrNumber ordattno = rel->max_attr;
2802 Var *var = NULL;
2803 ListCell *lc;
2804
2805 /*
2806 * Is there a Var for it in rel's targetlist? If not, the query did
2807 * not reference the ordinality column, or at least not in any way
2808 * that would be interesting for sorting.
2809 */
2810 foreach(lc, rel->reltarget->exprs)
2811 {
2812 Var *node = (Var *) lfirst(lc);
2813
2814 /* checking varno/varlevelsup is just paranoia */
2815 if (IsA(node, Var) &&
2816 node->varattno == ordattno &&
2817 node->varno == rel->relid &&
2818 node->varlevelsup == 0)
2819 {
2820 var = node;
2821 break;
2822 }
2823 }
2824
2825 /*
2826 * Try to build pathkeys for this Var with int8 sorting. We tell
2827 * build_expression_pathkey not to build any new equivalence class; if
2828 * the Var isn't already mentioned in some EC, it means that nothing
2829 * cares about the ordering.
2830 */
2831 if (var)
2832 pathkeys = build_expression_pathkey(root,
2833 (Expr *) var,
2834 Int8LessOperator,
2835 rel->relids,
2836 false);
2837 }
2838
2839 /* Generate appropriate path */
2840 add_path(rel, create_functionscan_path(root, rel,
2841 pathkeys, required_outer));
2842}
2843
2844/*
2845 * set_values_pathlist
2846 * Build the (single) access path for a VALUES RTE
2847 */
2848static void
2849set_values_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
2850{
2851 Relids required_outer;
2852
2853 /*
2854 * We don't support pushing join clauses into the quals of a values scan,
2855 * but it could still have required parameterization due to LATERAL refs
2856 * in the values expressions.
2857 */
2858 required_outer = rel->lateral_relids;
2859
2860 /* Generate appropriate path */
2861 add_path(rel, create_valuesscan_path(root, rel, required_outer));
2862}
2863
2864/*
2865 * set_tablefunc_pathlist
2866 * Build the (single) access path for a table func RTE
2867 */
2868static void
2869set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
2870{
2871 Relids required_outer;
2872
2873 /*
2874 * We don't support pushing join clauses into the quals of a tablefunc
2875 * scan, but it could still have required parameterization due to LATERAL
2876 * refs in the function expression.
2877 */
2878 required_outer = rel->lateral_relids;
2879
2880 /* Generate appropriate path */
2881 add_path(rel, create_tablefuncscan_path(root, rel,
2882 required_outer));
2883}
2884
2885/*
2886 * set_cte_pathlist
2887 * Build the (single) access path for a non-self-reference CTE RTE
2888 *
2889 * There's no need for a separate set_cte_size phase, since we don't
2890 * support join-qual-parameterized paths for CTEs.
2891 */
2892static void
2893set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
2894{
2895 Path *ctepath;
2896 Plan *cteplan;
2897 PlannerInfo *cteroot;
2898 Index levelsup;
2899 List *pathkeys;
2900 int ndx;
2901 ListCell *lc;
2902 int plan_id;
2903 Relids required_outer;
2904
2905 /*
2906 * Find the referenced CTE, and locate the path and plan previously made
2907 * for it.
2908 */
2909 levelsup = rte->ctelevelsup;
2910 cteroot = root;
2911 while (levelsup-- > 0)
2912 {
2913 cteroot = cteroot->parent_root;
2914 if (!cteroot) /* shouldn't happen */
2915 elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
2916 }
2917
2918 /*
2919 * Note: cte_plan_ids can be shorter than cteList, if we are still working
2920 * on planning the CTEs (ie, this is a side-reference from another CTE).
2921 * So we mustn't use forboth here.
2922 */
2923 ndx = 0;
2924 foreach(lc, cteroot->parse->cteList)
2925 {
2926 CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
2927
2928 if (strcmp(cte->ctename, rte->ctename) == 0)
2929 break;
2930 ndx++;
2931 }
2932 if (lc == NULL) /* shouldn't happen */
2933 elog(ERROR, "could not find CTE \"%s\"", rte->ctename);
2934 if (ndx >= list_length(cteroot->cte_plan_ids))
2935 elog(ERROR, "could not find plan for CTE \"%s\"", rte->ctename);
2936 plan_id = list_nth_int(cteroot->cte_plan_ids, ndx);
2937 if (plan_id <= 0)
2938 elog(ERROR, "no plan was made for CTE \"%s\"", rte->ctename);
2939
2940 Assert(list_length(root->glob->subpaths) == list_length(root->glob->subplans));
2941 ctepath = (Path *) list_nth(root->glob->subpaths, plan_id - 1);
2942 cteplan = (Plan *) list_nth(root->glob->subplans, plan_id - 1);
2943
2944 /* Mark rel with estimated output rows, width, etc */
2945 set_cte_size_estimates(root, rel, cteplan->plan_rows);
2946
2947 /* Convert the ctepath's pathkeys to outer query's representation */
2948 pathkeys = convert_subquery_pathkeys(root,
2949 rel,
2950 ctepath->pathkeys,
2951 cteplan->targetlist);
2952
2953 /*
2954 * We don't support pushing join clauses into the quals of a CTE scan, but
2955 * it could still have required parameterization due to LATERAL refs in
2956 * its tlist.
2957 */
2958 required_outer = rel->lateral_relids;
2959
2960 /* Generate appropriate path */
2961 add_path(rel, create_ctescan_path(root, rel, pathkeys, required_outer));
2962}
2963
2964/*
2965 * set_namedtuplestore_pathlist
2966 * Build the (single) access path for a named tuplestore RTE
2967 *
2968 * There's no need for a separate set_namedtuplestore_size phase, since we
2969 * don't support join-qual-parameterized paths for tuplestores.
2970 */
2971static void
2972set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel,
2973 RangeTblEntry *rte)
2974{
2975 Relids required_outer;
2976
2977 /* Mark rel with estimated output rows, width, etc */
2978 set_namedtuplestore_size_estimates(root, rel);
2979
2980 /*
2981 * We don't support pushing join clauses into the quals of a tuplestore
2982 * scan, but it could still have required parameterization due to LATERAL
2983 * refs in its tlist.
2984 */
2985 required_outer = rel->lateral_relids;
2986
2987 /* Generate appropriate path */
2988 add_path(rel, create_namedtuplestorescan_path(root, rel, required_outer));
2989}
2990
2991/*
2992 * set_result_pathlist
2993 * Build the (single) access path for an RTE_RESULT RTE
2994 *
2995 * There's no need for a separate set_result_size phase, since we
2996 * don't support join-qual-parameterized paths for these RTEs.
2997 */
2998static void
2999set_result_pathlist(PlannerInfo *root, RelOptInfo *rel,
3000 RangeTblEntry *rte)
3001{
3002 Relids required_outer;
3003
3004 /* Mark rel with estimated output rows, width, etc */
3005 set_result_size_estimates(root, rel);
3006
3007 /*
3008 * We don't support pushing join clauses into the quals of a Result scan,
3009 * but it could still have required parameterization due to LATERAL refs
3010 * in its tlist.
3011 */
3012 required_outer = rel->lateral_relids;
3013
3014 /* Generate appropriate path */
3015 add_path(rel, create_resultscan_path(root, rel, required_outer));
3016}
3017
3018/*
3019 * set_worktable_pathlist
3020 * Build the (single) access path for a self-reference CTE RTE
3021 *
3022 * There's no need for a separate set_worktable_size phase, since we don't
3023 * support join-qual-parameterized paths for CTEs.
3024 */
3025static void
3026set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
3027{
3028 Path *ctepath;
3029 PlannerInfo *cteroot;
3030 Index levelsup;
3031 Relids required_outer;
3032
3033 /*
3034 * We need to find the non-recursive term's path, which is in the plan
3035 * level that's processing the recursive UNION, which is one level *below*
3036 * where the CTE comes from.
3037 */
3038 levelsup = rte->ctelevelsup;
3039 if (levelsup == 0) /* shouldn't happen */
3040 elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
3041 levelsup--;
3042 cteroot = root;
3043 while (levelsup-- > 0)
3044 {
3045 cteroot = cteroot->parent_root;
3046 if (!cteroot) /* shouldn't happen */
3047 elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
3048 }
3049 ctepath = cteroot->non_recursive_path;
3050 if (!ctepath) /* shouldn't happen */
3051 elog(ERROR, "could not find path for CTE \"%s\"", rte->ctename);
3052
3053 /* Mark rel with estimated output rows, width, etc */
3054 set_cte_size_estimates(root, rel, ctepath->rows);
3055
3056 /*
3057 * We don't support pushing join clauses into the quals of a worktable
3058 * scan, but it could still have required parameterization due to LATERAL
3059 * refs in its tlist. (I'm not sure this is actually possible given the
3060 * restrictions on recursive references, but it's easy enough to support.)
3061 */
3062 required_outer = rel->lateral_relids;
3063
3064 /* Generate appropriate path */
3065 add_path(rel, create_worktablescan_path(root, rel, required_outer));
3066}
3067
3068/*
3069 * generate_gather_paths
3070 * Generate parallel access paths for a relation by pushing a Gather or
3071 * Gather Merge on top of a partial path.
3072 *
3073 * This must not be called until after we're done creating all partial paths
3074 * for the specified relation. (Otherwise, add_partial_path might delete a
3075 * path that some GatherPath or GatherMergePath has a reference to.)
3076 *
3077 * If we're generating paths for a scan or join relation, override_rows will
3078 * be false, and we'll just use the relation's size estimate. When we're
3079 * being called for a partially-grouped or partially-distinct path, though, we
3080 * need to override the rowcount estimate. (It's not clear that the
3081 * particular value we're using here is actually best, but the underlying rel
3082 * has no estimate so we must do something.)
3083 */
3084void
3085generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
3086{
3087 Path *cheapest_partial_path;
3088 Path *simple_gather_path;
3089 ListCell *lc;
3090 double rows;
3091 double *rowsp = NULL;
3092
3093 /* If there are no partial paths, there's nothing to do here. */
3094 if (rel->partial_pathlist == NIL)
3095 return;
3096
3097 /* Should we override the rel's rowcount estimate? */
3098 if (override_rows)
3099 rowsp = &rows;
3100
3101 /*
3102 * The output of Gather is always unsorted, so there's only one partial
3103 * path of interest: the cheapest one. That will be the one at the front
3104 * of partial_pathlist because of the way add_partial_path works.
3105 */
3106 cheapest_partial_path = linitial(rel->partial_pathlist);
3107 rows = compute_gather_rows(cheapest_partial_path);
3108 simple_gather_path = (Path *)
3109 create_gather_path(root, rel, cheapest_partial_path, rel->reltarget,
3110 NULL, rowsp);
3111 add_path(rel, simple_gather_path);
3112
3113 /*
3114 * For each useful ordering, we can consider an order-preserving Gather
3115 * Merge.
3116 */
3117 foreach(lc, rel->partial_pathlist)
3118 {
3119 Path *subpath = (Path *) lfirst(lc);
3120 GatherMergePath *path;
3121
3122 if (subpath->pathkeys == NIL)
3123 continue;
3124
3125 rows = compute_gather_rows(subpath);
3126 path = create_gather_merge_path(root, rel, subpath, rel->reltarget,
3127 subpath->pathkeys, NULL, rowsp);
3128 add_path(rel, &path->path);
3129 }
3130}
3131
3132/*
3133 * get_useful_pathkeys_for_relation
3134 * Determine which orderings of a relation might be useful.
3135 *
3136 * Getting data in sorted order can be useful either because the requested
3137 * order matches the final output ordering for the overall query we're
3138 * planning, or because it enables an efficient merge join. Here, we try
3139 * to figure out which pathkeys to consider.
3140 *
3141 * This allows us to do incremental sort on top of an index scan under a gather
3142 * merge node, i.e. parallelized.
3143 *
3144 * If the require_parallel_safe is true, we also require the expressions to
3145 * be parallel safe (which allows pushing the sort below Gather Merge).
3146 *
3147 * XXX At the moment this can only ever return a list with a single element,
3148 * because it looks at query_pathkeys only. So we might return the pathkeys
3149 * directly, but it seems plausible we'll want to consider other orderings
3150 * in the future. For example, we might want to consider pathkeys useful for
3151 * merge joins.
3152 */
3153static List *
3154get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel,
3155 bool require_parallel_safe)
3156{
3157 List *useful_pathkeys_list = NIL;
3158
3159 /*
3160 * Considering query_pathkeys is always worth it, because it might allow
3161 * us to avoid a total sort when we have a partially presorted path
3162 * available or to push the total sort into the parallel portion of the
3163 * query.
3164 */
3165 if (root->query_pathkeys)
3166 {
3167 ListCell *lc;
3168 int npathkeys = 0; /* useful pathkeys */
3169
3170 foreach(lc, root->query_pathkeys)
3171 {
3172 PathKey *pathkey = (PathKey *) lfirst(lc);
3173 EquivalenceClass *pathkey_ec = pathkey->pk_eclass;
3174
3175 /*
3176 * We can only build a sort for pathkeys that contain a
3177 * safe-to-compute-early EC member computable from the current
3178 * relation's reltarget, so ignore the remainder of the list as
3179 * soon as we find a pathkey without such a member.
3180 *
3181 * It's still worthwhile to return any prefix of the pathkeys list
3182 * that meets this requirement, as we may be able to do an
3183 * incremental sort.
3184 *
3185 * If requested, ensure the sort expression is parallel-safe too.
3186 */
3187 if (!relation_can_be_sorted_early(root, rel, pathkey_ec,
3188 require_parallel_safe))
3189 break;
3190
3191 npathkeys++;
3192 }
3193
3194 /*
3195 * The whole query_pathkeys list matches, so append it directly, to
3196 * allow comparing pathkeys easily by comparing list pointer. If we
3197 * have to truncate the pathkeys, we gotta do a copy though.
3198 */
3199 if (npathkeys == list_length(root->query_pathkeys))
3200 useful_pathkeys_list = lappend(useful_pathkeys_list,
3201 root->query_pathkeys);
3202 else if (npathkeys > 0)
3203 useful_pathkeys_list = lappend(useful_pathkeys_list,
3204 list_copy_head(root->query_pathkeys,
3205 npathkeys));
3206 }
3207
3208 return useful_pathkeys_list;
3209}
3210
3211/*
3212 * generate_useful_gather_paths
3213 * Generate parallel access paths for a relation by pushing a Gather or
3214 * Gather Merge on top of a partial path.
3215 *
3216 * Unlike plain generate_gather_paths, this looks both at pathkeys of input
3217 * paths (aiming to preserve the ordering), but also considers ordering that
3218 * might be useful for nodes above the gather merge node, and tries to add
3219 * a sort (regular or incremental) to provide that.
3220 */
3221void
3222generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
3223{
3224 ListCell *lc;
3225 double rows;
3226 double *rowsp = NULL;
3227 List *useful_pathkeys_list = NIL;
3228 Path *cheapest_partial_path = NULL;
3229
3230 /* If there are no partial paths, there's nothing to do here. */
3231 if (rel->partial_pathlist == NIL)
3232 return;
3233
3234 /* Should we override the rel's rowcount estimate? */
3235 if (override_rows)
3236 rowsp = &rows;
3237
3238 /* generate the regular gather (merge) paths */
3239 generate_gather_paths(root, rel, override_rows);
3240
3241 /* consider incremental sort for interesting orderings */
3242 useful_pathkeys_list = get_useful_pathkeys_for_relation(root, rel, true);
3243
3244 /* used for explicit (full) sort paths */
3245 cheapest_partial_path = linitial(rel->partial_pathlist);
3246
3247 /*
3248 * Consider sorted paths for each interesting ordering. We generate both
3249 * incremental and full sort.
3250 */
3251 foreach(lc, useful_pathkeys_list)
3252 {
3253 List *useful_pathkeys = lfirst(lc);
3254 ListCell *lc2;
3255 bool is_sorted;
3256 int presorted_keys;
3257
3258 foreach(lc2, rel->partial_pathlist)
3259 {
3260 Path *subpath = (Path *) lfirst(lc2);
3261 GatherMergePath *path;
3262
3263 is_sorted = pathkeys_count_contained_in(useful_pathkeys,
3264 subpath->pathkeys,
3265 &presorted_keys);
3266
3267 /*
3268 * We don't need to consider the case where a subpath is already
3269 * fully sorted because generate_gather_paths already creates a
3270 * gather merge path for every subpath that has pathkeys present.
3271 *
3272 * But since the subpath is already sorted, we know we don't need
3273 * to consider adding a sort (full or incremental) on top of it,
3274 * so we can continue here.
3275 */
3276 if (is_sorted)
3277 continue;
3278
3279 /*
3280 * Try at least sorting the cheapest path and also try
3281 * incrementally sorting any path which is partially sorted
3282 * already (no need to deal with paths which have presorted keys
3283 * when incremental sort is disabled unless it's the cheapest
3284 * input path).
3285 */
3286 if (subpath != cheapest_partial_path &&
3287 (presorted_keys == 0 || !enable_incremental_sort))
3288 continue;
3289
3290 /*
3291 * Consider regular sort for any path that's not presorted or if
3292 * incremental sort is disabled. We've no need to consider both
3293 * sort and incremental sort on the same path. We assume that
3294 * incremental sort is always faster when there are presorted
3295 * keys.
3296 *
3297 * This is not redundant with the gather paths created in
3298 * generate_gather_paths, because that doesn't generate ordered
3299 * output. Here we add an explicit sort to match the useful
3300 * ordering.
3301 */
3302 if (presorted_keys == 0 || !enable_incremental_sort)
3303 {
3304 subpath = (Path *) create_sort_path(root,
3305 rel,
3306 subpath,
3307 useful_pathkeys,
3308 -1.0);
3309 }
3310 else
3311 subpath = (Path *) create_incremental_sort_path(root,
3312 rel,
3313 subpath,
3314 useful_pathkeys,
3315 presorted_keys,
3316 -1);
3317 rows = compute_gather_rows(subpath);
3318 path = create_gather_merge_path(root, rel,
3319 subpath,
3320 rel->reltarget,
3321 subpath->pathkeys,
3322 NULL,
3323 rowsp);
3324
3325 add_path(rel, &path->path);
3326 }
3327 }
3328}
3329
3330/*
3331 * make_rel_from_joinlist
3332 * Build access paths using a "joinlist" to guide the join path search.
3333 *
3334 * See comments for deconstruct_jointree() for definition of the joinlist
3335 * data structure.
3336 */
3337static RelOptInfo *
3338make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
3339{
3340 int levels_needed;
3341 List *initial_rels;
3342 ListCell *jl;
3343
3344 /*
3345 * Count the number of child joinlist nodes. This is the depth of the
3346 * dynamic-programming algorithm we must employ to consider all ways of
3347 * joining the child nodes.
3348 */
3349 levels_needed = list_length(joinlist);
3350
3351 if (levels_needed <= 0)
3352 return NULL; /* nothing to do? */
3353
3354 /*
3355 * Construct a list of rels corresponding to the child joinlist nodes.
3356 * This may contain both base rels and rels constructed according to
3357 * sub-joinlists.
3358 */
3359 initial_rels = NIL;
3360 foreach(jl, joinlist)
3361 {
3362 Node *jlnode = (Node *) lfirst(jl);
3363 RelOptInfo *thisrel;
3364
3365 if (IsA(jlnode, RangeTblRef))
3366 {
3367 int varno = ((RangeTblRef *) jlnode)->rtindex;
3368
3369 thisrel = find_base_rel(root, varno);
3370 }
3371 else if (IsA(jlnode, List))
3372 {
3373 /* Recurse to handle subproblem */
3374 thisrel = make_rel_from_joinlist(root, (List *) jlnode);
3375 }
3376 else
3377 {
3378 elog(ERROR, "unrecognized joinlist node type: %d",
3379 (int) nodeTag(jlnode));
3380 thisrel = NULL; /* keep compiler quiet */
3381 }
3382
3383 initial_rels = lappend(initial_rels, thisrel);
3384 }
3385
3386 if (levels_needed == 1)
3387 {
3388 /*
3389 * Single joinlist node, so we're done.
3390 */
3391 return (RelOptInfo *) linitial(initial_rels);
3392 }
3393 else
3394 {
3395 /*
3396 * Consider the different orders in which we could join the rels,
3397 * using a plugin, GEQO, or the regular join search code.
3398 *
3399 * We put the initial_rels list into a PlannerInfo field because
3400 * has_legal_joinclause() needs to look at it (ugly :-().
3401 */
3402 root->initial_rels = initial_rels;
3403
3404 if (join_search_hook)
3405 return (*join_search_hook) (root, levels_needed, initial_rels);
3406 else if (enable_geqo && levels_needed >= geqo_threshold)
3407 return geqo(root, levels_needed, initial_rels);
3408 else
3409 return standard_join_search(root, levels_needed, initial_rels);
3410 }
3411}
3412
3413/*
3414 * standard_join_search
3415 * Find possible joinpaths for a query by successively finding ways
3416 * to join component relations into join relations.
3417 *
3418 * 'levels_needed' is the number of iterations needed, ie, the number of
3419 * independent jointree items in the query. This is > 1.
3420 *
3421 * 'initial_rels' is a list of RelOptInfo nodes for each independent
3422 * jointree item. These are the components to be joined together.
3423 * Note that levels_needed == list_length(initial_rels).
3424 *
3425 * Returns the final level of join relations, i.e., the relation that is
3426 * the result of joining all the original relations together.
3427 * At least one implementation path must be provided for this relation and
3428 * all required sub-relations.
3429 *
3430 * To support loadable plugins that modify planner behavior by changing the
3431 * join searching algorithm, we provide a hook variable that lets a plugin
3432 * replace or supplement this function. Any such hook must return the same
3433 * final join relation as the standard code would, but it might have a
3434 * different set of implementation paths attached, and only the sub-joinrels
3435 * needed for these paths need have been instantiated.
3436 *
3437 * Note to plugin authors: the functions invoked during standard_join_search()
3438 * modify root->join_rel_list and root->join_rel_hash. If you want to do more
3439 * than one join-order search, you'll probably need to save and restore the
3440 * original states of those data structures. See geqo_eval() for an example.
3441 */
3442RelOptInfo *
3443standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
3444{
3445 int lev;
3446 RelOptInfo *rel;
3447
3448 /*
3449 * This function cannot be invoked recursively within any one planning
3450 * problem, so join_rel_level[] can't be in use already.
3451 */
3452 Assert(root->join_rel_level == NULL);
3453
3454 /*
3455 * We employ a simple "dynamic programming" algorithm: we first find all
3456 * ways to build joins of two jointree items, then all ways to build joins
3457 * of three items (from two-item joins and single items), then four-item
3458 * joins, and so on until we have considered all ways to join all the
3459 * items into one rel.
3460 *
3461 * root->join_rel_level[j] is a list of all the j-item rels. Initially we
3462 * set root->join_rel_level[1] to represent all the single-jointree-item
3463 * relations.
3464 */
3465 root->join_rel_level = (List **) palloc0((levels_needed + 1) * sizeof(List *));
3466
3467 root->join_rel_level[1] = initial_rels;
3468
3469 for (lev = 2; lev <= levels_needed; lev++)
3470 {
3471 ListCell *lc;
3472
3473 /*
3474 * Determine all possible pairs of relations to be joined at this
3475 * level, and build paths for making each one from every available
3476 * pair of lower-level relations.
3477 */
3478 join_search_one_level(root, lev);
3479
3480 /*
3481 * Run generate_partitionwise_join_paths() and
3482 * generate_useful_gather_paths() for each just-processed joinrel. We
3483 * could not do this earlier because both regular and partial paths
3484 * can get added to a particular joinrel at multiple times within
3485 * join_search_one_level.
3486 *
3487 * After that, we're done creating paths for the joinrel, so run
3488 * set_cheapest().
3489 */
3490 foreach(lc, root->join_rel_level[lev])
3491 {
3492 rel = (RelOptInfo *) lfirst(lc);
3493
3494 /* Create paths for partitionwise joins. */
3495 generate_partitionwise_join_paths(root, rel);
3496
3497 /*
3498 * Except for the topmost scan/join rel, consider gathering
3499 * partial paths. We'll do the same for the topmost scan/join rel
3500 * once we know the final targetlist (see grouping_planner's and
3501 * its call to apply_scanjoin_target_to_paths).
3502 */
3503 if (!bms_equal(rel->relids, root->all_query_rels))
3504 generate_useful_gather_paths(root, rel, false);
3505
3506 /* Find and save the cheapest paths for this rel */
3507 set_cheapest(rel);
3508
3509#ifdef OPTIMIZER_DEBUG
3510 pprint(rel);
3511#endif
3512 }
3513 }
3514
3515 /*
3516 * We should have a single rel at the final level.
3517 */
3518 if (root->join_rel_level[levels_needed] == NIL)
3519 elog(ERROR, "failed to build any %d-way joins", levels_needed);
3520 Assert(list_length(root->join_rel_level[levels_needed]) == 1);
3521
3522 rel = (RelOptInfo *) linitial(root->join_rel_level[levels_needed]);
3523
3524 root->join_rel_level = NULL;
3525
3526 return rel;
3527}
3528
3529/*****************************************************************************
3530 * PUSHING QUALS DOWN INTO SUBQUERIES
3531 *****************************************************************************/
3532
3533/*
3534 * subquery_is_pushdown_safe - is a subquery safe for pushing down quals?
3535 *
3536 * subquery is the particular component query being checked. topquery
3537 * is the top component of a set-operations tree (the same Query if no
3538 * set-op is involved).
3539 *
3540 * Conditions checked here:
3541 *
3542 * 1. If the subquery has a LIMIT clause, we must not push down any quals,
3543 * since that could change the set of rows returned.
3544 *
3545 * 2. If the subquery contains EXCEPT or EXCEPT ALL set ops we cannot push
3546 * quals into it, because that could change the results.
3547 *
3548 * 3. If the subquery uses DISTINCT, we cannot push volatile quals into it.
3549 * This is because upper-level quals should semantically be evaluated only
3550 * once per distinct row, not once per original row, and if the qual is
3551 * volatile then extra evaluations could change the results. (This issue
3552 * does not apply to other forms of aggregation such as GROUP BY, because
3553 * when those are present we push into HAVING not WHERE, so that the quals
3554 * are still applied after aggregation.)
3555 *
3556 * 4. If the subquery contains window functions, we cannot push volatile quals
3557 * into it. The issue here is a bit different from DISTINCT: a volatile qual
3558 * might succeed for some rows of a window partition and fail for others,
3559 * thereby changing the partition contents and thus the window functions'
3560 * results for rows that remain.
3561 *
3562 * 5. If the subquery contains any set-returning functions in its targetlist,
3563 * we cannot push volatile quals into it. That would push them below the SRFs
3564 * and thereby change the number of times they are evaluated. Also, a
3565 * volatile qual could succeed for some SRF output rows and fail for others,
3566 * a behavior that cannot occur if it's evaluated before SRF expansion.
3567 *
3568 * 6. If the subquery has nonempty grouping sets, we cannot push down any
3569 * quals. The concern here is that a qual referencing a "constant" grouping
3570 * column could get constant-folded, which would be improper because the value
3571 * is potentially nullable by grouping-set expansion. This restriction could
3572 * be removed if we had a parsetree representation that shows that such
3573 * grouping columns are not really constant. (There are other ideas that
3574 * could be used to relax this restriction, but that's the approach most
3575 * likely to get taken in the future. Note that there's not much to be gained
3576 * so long as subquery_planner can't move HAVING clauses to WHERE within such
3577 * a subquery.)
3578 *
3579 * In addition, we make several checks on the subquery's output columns to see
3580 * if it is safe to reference them in pushed-down quals. If output column k
3581 * is found to be unsafe to reference, we set the reason for that inside
3582 * safetyInfo->unsafeFlags[k], but we don't reject the subquery overall since
3583 * column k might not be referenced by some/all quals. The unsafeFlags[]
3584 * array will be consulted later by qual_is_pushdown_safe(). It's better to
3585 * do it this way than to make the checks directly in qual_is_pushdown_safe(),
3586 * because when the subquery involves set operations we have to check the
3587 * output expressions in each arm of the set op.
3588 *
3589 * Note: pushing quals into a DISTINCT subquery is theoretically dubious:
3590 * we're effectively assuming that the quals cannot distinguish values that
3591 * the DISTINCT's equality operator sees as equal, yet there are many
3592 * counterexamples to that assumption. However use of such a qual with a
3593 * DISTINCT subquery would be unsafe anyway, since there's no guarantee which
3594 * "equal" value will be chosen as the output value by the DISTINCT operation.
3595 * So we don't worry too much about that. Another objection is that if the
3596 * qual is expensive to evaluate, running it for each original row might cost
3597 * more than we save by eliminating rows before the DISTINCT step. But it
3598 * would be very hard to estimate that at this stage, and in practice pushdown
3599 * seldom seems to make things worse, so we ignore that problem too.
3600 *
3601 * Note: likewise, pushing quals into a subquery with window functions is a
3602 * bit dubious: the quals might remove some rows of a window partition while
3603 * leaving others, causing changes in the window functions' results for the
3604 * surviving rows. We insist that such a qual reference only partitioning
3605 * columns, but again that only protects us if the qual does not distinguish
3606 * values that the partitioning equality operator sees as equal. The risks
3607 * here are perhaps larger than for DISTINCT, since no de-duplication of rows
3608 * occurs and thus there is no theoretical problem with such a qual. But
3609 * we'll do this anyway because the potential performance benefits are very
3610 * large, and we've seen no field complaints about the longstanding comparable
3611 * behavior with DISTINCT.
3612 */
3613static bool
3614subquery_is_pushdown_safe(Query *subquery, Query *topquery,
3615 pushdown_safety_info *safetyInfo)
3616{
3617 SetOperationStmt *topop;
3618
3619 /* Check point 1 */
3620 if (subquery->limitOffset != NULL || subquery->limitCount != NULL)
3621 return false;
3622
3623 /* Check point 6 */
3624 if (subquery->groupClause && subquery->groupingSets)
3625 return false;
3626
3627 /* Check points 3, 4, and 5 */
3628 if (subquery->distinctClause ||
3629 subquery->hasWindowFuncs ||
3630 subquery->hasTargetSRFs)
3631 safetyInfo->unsafeVolatile = true;
3632
3633 /*
3634 * If we're at a leaf query, check for unsafe expressions in its target
3635 * list, and mark any reasons why they're unsafe in unsafeFlags[].
3636 * (Non-leaf nodes in setop trees have only simple Vars in their tlists,
3637 * so no need to check them.)
3638 */
3639 if (subquery->setOperations == NULL)
3640 check_output_expressions(subquery, safetyInfo);
3641
3642 /* Are we at top level, or looking at a setop component? */
3643 if (subquery == topquery)
3644 {
3645 /* Top level, so check any component queries */
3646 if (subquery->setOperations != NULL)
3647 if (!recurse_pushdown_safe(subquery->setOperations, topquery,
3648 safetyInfo))
3649 return false;
3650 }
3651 else
3652 {
3653 /* Setop component must not have more components (too weird) */
3654 if (subquery->setOperations != NULL)
3655 return false;
3656 /* Check whether setop component output types match top level */
3657 topop = castNode(SetOperationStmt, topquery->setOperations);
3658 Assert(topop);
3659 compare_tlist_datatypes(subquery->targetList,
3660 topop->colTypes,
3661 safetyInfo);
3662 }
3663 return true;
3664}
3665
3666/*
3667 * Helper routine to recurse through setOperations tree
3668 */
3669static bool
3670recurse_pushdown_safe(Node *setOp, Query *topquery,
3671 pushdown_safety_info *safetyInfo)
3672{
3673 if (IsA(setOp, RangeTblRef))
3674 {
3675 RangeTblRef *rtr = (RangeTblRef *) setOp;
3676 RangeTblEntry *rte = rt_fetch(rtr->rtindex, topquery->rtable);
3677 Query *subquery = rte->subquery;
3678
3679 Assert(subquery != NULL);
3680 return subquery_is_pushdown_safe(subquery, topquery, safetyInfo);
3681 }
3682 else if (IsA(setOp, SetOperationStmt))
3683 {
3684 SetOperationStmt *op = (SetOperationStmt *) setOp;
3685
3686 /* EXCEPT is no good (point 2 for subquery_is_pushdown_safe) */
3687 if (op->op == SETOP_EXCEPT)
3688 return false;
3689 /* Else recurse */
3690 if (!recurse_pushdown_safe(op->larg, topquery, safetyInfo))
3691 return false;
3692 if (!recurse_pushdown_safe(op->rarg, topquery, safetyInfo))
3693 return false;
3694 }
3695 else
3696 {
3697 elog(ERROR, "unrecognized node type: %d",
3698 (int) nodeTag(setOp));
3699 }
3700 return true;
3701}
3702
3703/*
3704 * check_output_expressions - check subquery's output expressions for safety
3705 *
3706 * There are several cases in which it's unsafe to push down an upper-level
3707 * qual if it references a particular output column of a subquery. We check
3708 * each output column of the subquery and set flags in unsafeFlags[k] when we
3709 * see that column is unsafe for a pushed-down qual to reference. The
3710 * conditions checked here are:
3711 *
3712 * 1. We must not push down any quals that refer to subselect outputs that
3713 * return sets, else we'd introduce functions-returning-sets into the
3714 * subquery's WHERE/HAVING quals.
3715 *
3716 * 2. We must not push down any quals that refer to subselect outputs that
3717 * contain volatile functions, for fear of introducing strange results due
3718 * to multiple evaluation of a volatile function.
3719 *
3720 * 3. If the subquery uses DISTINCT ON, we must not push down any quals that
3721 * refer to non-DISTINCT output columns, because that could change the set
3722 * of rows returned. (This condition is vacuous for DISTINCT, because then
3723 * there are no non-DISTINCT output columns, so we needn't check. Note that
3724 * subquery_is_pushdown_safe already reported that we can't use volatile
3725 * quals if there's DISTINCT or DISTINCT ON.)
3726 *
3727 * 4. If the subquery has any window functions, we must not push down quals
3728 * that reference any output columns that are not listed in all the subquery's
3729 * window PARTITION BY clauses. We can push down quals that use only
3730 * partitioning columns because they should succeed or fail identically for
3731 * every row of any one window partition, and totally excluding some
3732 * partitions will not change a window function's results for remaining
3733 * partitions. (Again, this also requires nonvolatile quals, but
3734 * subquery_is_pushdown_safe handles that.). Subquery columns marked as
3735 * unsafe for this reason can still have WindowClause run conditions pushed
3736 * down.
3737 */
3738static void
3739check_output_expressions(Query *subquery, pushdown_safety_info *safetyInfo)
3740{
3741 ListCell *lc;
3742
3743 foreach(lc, subquery->targetList)
3744 {
3745 TargetEntry *tle = (TargetEntry *) lfirst(lc);
3746
3747 if (tle->resjunk)
3748 continue; /* ignore resjunk columns */
3749
3750 /* Functions returning sets are unsafe (point 1) */
3751 if (subquery->hasTargetSRFs &&
3752 (safetyInfo->unsafeFlags[tle->resno] &
3753 UNSAFE_HAS_SET_FUNC) == 0 &&
3754 expression_returns_set((Node *) tle->expr))
3755 {
3756 safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_HAS_SET_FUNC;
3757 continue;
3758 }
3759
3760 /* Volatile functions are unsafe (point 2) */
3761 if ((safetyInfo->unsafeFlags[tle->resno] &
3762 UNSAFE_HAS_VOLATILE_FUNC) == 0 &&
3763 contain_volatile_functions((Node *) tle->expr))
3764 {
3765 safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_HAS_VOLATILE_FUNC;
3766 continue;
3767 }
3768
3769 /* If subquery uses DISTINCT ON, check point 3 */
3770 if (subquery->hasDistinctOn &&
3771 (safetyInfo->unsafeFlags[tle->resno] &
3772 UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
3773 !targetIsInSortList(tle, InvalidOid, subquery->distinctClause))
3774 {
3775 /* non-DISTINCT column, so mark it unsafe */
3776 safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_NOTIN_DISTINCTON_CLAUSE;
3777 continue;
3778 }
3779
3780 /* If subquery uses window functions, check point 4 */
3781 if (subquery->hasWindowFuncs &&
3782 (safetyInfo->unsafeFlags[tle->resno] &
3783 UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
3784 !targetIsInAllPartitionLists(tle, subquery))
3785 {
3786 /* not present in all PARTITION BY clauses, so mark it unsafe */
3787 safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_NOTIN_PARTITIONBY_CLAUSE;
3788 continue;
3789 }
3790 }
3791}
3792
3793/*
3794 * For subqueries using UNION/UNION ALL/INTERSECT/INTERSECT ALL, we can
3795 * push quals into each component query, but the quals can only reference
3796 * subquery columns that suffer no type coercions in the set operation.
3797 * Otherwise there are possible semantic gotchas. So, we check the
3798 * component queries to see if any of them have output types different from
3799 * the top-level setop outputs. We set the UNSAFE_TYPE_MISMATCH bit in
3800 * unsafeFlags[k] if column k has different type in any component.
3801 *
3802 * We don't have to care about typmods here: the only allowed difference
3803 * between set-op input and output typmods is input is a specific typmod
3804 * and output is -1, and that does not require a coercion.
3805 *
3806 * tlist is a subquery tlist.
3807 * colTypes is an OID list of the top-level setop's output column types.
3808 * safetyInfo is the pushdown_safety_info to set unsafeFlags[] for.
3809 */
3810static void
3811compare_tlist_datatypes(List *tlist, List *colTypes,
3812 pushdown_safety_info *safetyInfo)
3813{
3814 ListCell *l;
3815 ListCell *colType = list_head(colTypes);
3816
3817 foreach(l, tlist)
3818 {
3819 TargetEntry *tle = (TargetEntry *) lfirst(l);
3820
3821 if (tle->resjunk)
3822 continue; /* ignore resjunk columns */
3823 if (colType == NULL)
3824 elog(ERROR, "wrong number of tlist entries");
3825 if (exprType((Node *) tle->expr) != lfirst_oid(colType))
3826 safetyInfo->unsafeFlags[tle->resno] |= UNSAFE_TYPE_MISMATCH;
3827 colType = lnext(colTypes, colType);
3828 }
3829 if (colType != NULL)
3830 elog(ERROR, "wrong number of tlist entries");
3831}
3832
3833/*
3834 * targetIsInAllPartitionLists
3835 * True if the TargetEntry is listed in the PARTITION BY clause
3836 * of every window defined in the query.
3837 *
3838 * It would be safe to ignore windows not actually used by any window
3839 * function, but it's not easy to get that info at this stage; and it's
3840 * unlikely to be useful to spend any extra cycles getting it, since
3841 * unreferenced window definitions are probably infrequent in practice.
3842 */
3843static bool
3844targetIsInAllPartitionLists(TargetEntry *tle, Query *query)
3845{
3846 ListCell *lc;
3847
3848 foreach(lc, query->windowClause)
3849 {
3850 WindowClause *wc = (WindowClause *) lfirst(lc);
3851
3852 if (!targetIsInSortList(tle, InvalidOid, wc->partitionClause))
3853 return false;
3854 }
3855 return true;
3856}
3857
3858/*
3859 * qual_is_pushdown_safe - is a particular rinfo safe to push down?
3860 *
3861 * rinfo is a restriction clause applying to the given subquery (whose RTE
3862 * has index rti in the parent query).
3863 *
3864 * Conditions checked here:
3865 *
3866 * 1. rinfo's clause must not contain any SubPlans (mainly because it's
3867 * unclear that it will work correctly: SubLinks will already have been
3868 * transformed into SubPlans in the qual, but not in the subquery). Note that
3869 * SubLinks that transform to initplans are safe, and will be accepted here
3870 * because what we'll see in the qual is just a Param referencing the initplan
3871 * output.
3872 *
3873 * 2. If unsafeVolatile is set, rinfo's clause must not contain any volatile
3874 * functions.
3875 *
3876 * 3. If unsafeLeaky is set, rinfo's clause must not contain any leaky
3877 * functions that are passed Var nodes, and therefore might reveal values from
3878 * the subquery as side effects.
3879 *
3880 * 4. rinfo's clause must not refer to the whole-row output of the subquery
3881 * (since there is no easy way to name that within the subquery itself).
3882 *
3883 * 5. rinfo's clause must not refer to any subquery output columns that were
3884 * found to be unsafe to reference by subquery_is_pushdown_safe().
3885 */
3886static pushdown_safe_type
3887qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo,
3888 pushdown_safety_info *safetyInfo)
3889{
3890 pushdown_safe_type safe = PUSHDOWN_SAFE;
3891 Node *qual = (Node *) rinfo->clause;
3892 List *vars;
3893 ListCell *vl;
3894
3895 /* Refuse subselects (point 1) */
3896 if (contain_subplans(qual))
3897 return PUSHDOWN_UNSAFE;
3898
3899 /* Refuse volatile quals if we found they'd be unsafe (point 2) */
3900 if (safetyInfo->unsafeVolatile &&
3901 contain_volatile_functions((Node *) rinfo))
3902 return PUSHDOWN_UNSAFE;
3903
3904 /* Refuse leaky quals if told to (point 3) */
3905 if (safetyInfo->unsafeLeaky &&
3906 contain_leaked_vars(qual))
3907 return PUSHDOWN_UNSAFE;
3908
3909 /*
3910 * Examine all Vars used in clause. Since it's a restriction clause, all
3911 * such Vars must refer to subselect output columns ... unless this is
3912 * part of a LATERAL subquery, in which case there could be lateral
3913 * references.
3914 *
3915 * By omitting the relevant flags, this also gives us a cheap sanity check
3916 * that no aggregates or window functions appear in the qual. Those would
3917 * be unsafe to push down, but at least for the moment we could never see
3918 * any in a qual anyhow.
3919 */
3920 vars = pull_var_clause(qual, PVC_INCLUDE_PLACEHOLDERS);
3921 foreach(vl, vars)
3922 {
3923 Var *var = (Var *) lfirst(vl);
3924
3925 /*
3926 * XXX Punt if we find any PlaceHolderVars in the restriction clause.
3927 * It's not clear whether a PHV could safely be pushed down, and even
3928 * less clear whether such a situation could arise in any cases of
3929 * practical interest anyway. So for the moment, just refuse to push
3930 * down.
3931 */
3932 if (!IsA(var, Var))
3933 {
3934 safe = PUSHDOWN_UNSAFE;
3935 break;
3936 }
3937
3938 /*
3939 * Punt if we find any lateral references. It would be safe to push
3940 * these down, but we'd have to convert them into outer references,
3941 * which subquery_push_qual lacks the infrastructure to do. The case
3942 * arises so seldom that it doesn't seem worth working hard on.
3943 */
3944 if (var->varno != rti)
3945 {
3946 safe = PUSHDOWN_UNSAFE;
3947 break;
3948 }
3949
3950 /* Subqueries have no system columns */
3951 Assert(var->varattno >= 0);
3952
3953 /* Check point 4 */
3954 if (var->varattno == 0)
3955 {
3956 safe = PUSHDOWN_UNSAFE;
3957 break;
3958 }
3959
3960 /* Check point 5 */
3961 if (safetyInfo->unsafeFlags[var->varattno] != 0)
3962 {
3963 if (safetyInfo->unsafeFlags[var->varattno] &
3964 (UNSAFE_HAS_VOLATILE_FUNC | UNSAFE_HAS_SET_FUNC |
3965 UNSAFE_NOTIN_DISTINCTON_CLAUSE | UNSAFE_TYPE_MISMATCH))
3966 {
3967 safe = PUSHDOWN_UNSAFE;
3968 break;
3969 }
3970 else
3971 {
3972 /* UNSAFE_NOTIN_PARTITIONBY_CLAUSE is ok for run conditions */
3973 safe = PUSHDOWN_WINDOWCLAUSE_RUNCOND;
3974 /* don't break, we might find another Var that's unsafe */
3975 }
3976 }
3977 }
3978
3979 list_free(vars);
3980
3981 return safe;
3982}
3983
3984/*
3985 * subquery_push_qual - push down a qual that we have determined is safe
3986 */
3987static void
3988subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
3989{
3990 if (subquery->setOperations != NULL)
3991 {
3992 /* Recurse to push it separately to each component query */
3993 recurse_push_qual(subquery->setOperations, subquery,
3994 rte, rti, qual);
3995 }
3996 else
3997 {
3998 /*
3999 * We need to replace Vars in the qual (which must refer to outputs of
4000 * the subquery) with copies of the subquery's targetlist expressions.
4001 * Note that at this point, any uplevel Vars in the qual should have
4002 * been replaced with Params, so they need no work.
4003 *
4004 * This step also ensures that when we are pushing into a setop tree,
4005 * each component query gets its own copy of the qual.
4006 */
4007 qual = ReplaceVarsFromTargetList(qual, rti, 0, rte,
4008 subquery->targetList,
4009 subquery->resultRelation,
4010 REPLACEVARS_REPORT_ERROR, 0,
4011 &subquery->hasSubLinks);
4012
4013 /*
4014 * Now attach the qual to the proper place: normally WHERE, but if the
4015 * subquery uses grouping or aggregation, put it in HAVING (since the
4016 * qual really refers to the group-result rows).
4017 */
4018 if (subquery->hasAggs || subquery->groupClause || subquery->groupingSets || subquery->havingQual)
4019 subquery->havingQual = make_and_qual(subquery->havingQual, qual);
4020 else
4021 subquery->jointree->quals =
4022 make_and_qual(subquery->jointree->quals, qual);
4023
4024 /*
4025 * We need not change the subquery's hasAggs or hasSubLinks flags,
4026 * since we can't be pushing down any aggregates that weren't there
4027 * before, and we don't push down subselects at all.
4028 */
4029 }
4030}
4031
4032/*
4033 * Helper routine to recurse through setOperations tree
4034 */
4035static void
4036recurse_push_qual(Node *setOp, Query *topquery,
4037 RangeTblEntry *rte, Index rti, Node *qual)
4038{
4039 if (IsA(setOp, RangeTblRef))
4040 {
4041 RangeTblRef *rtr = (RangeTblRef *) setOp;
4042 RangeTblEntry *subrte = rt_fetch(rtr->rtindex, topquery->rtable);
4043 Query *subquery = subrte->subquery;
4044
4045 Assert(subquery != NULL);
4046 subquery_push_qual(subquery, rte, rti, qual);
4047 }
4048 else if (IsA(setOp, SetOperationStmt))
4049 {
4050 SetOperationStmt *op = (SetOperationStmt *) setOp;
4051
4052 recurse_push_qual(op->larg, topquery, rte, rti, qual);
4053 recurse_push_qual(op->rarg, topquery, rte, rti, qual);
4054 }
4055 else
4056 {
4057 elog(ERROR, "unrecognized node type: %d",
4058 (int) nodeTag(setOp));
4059 }
4060}
4061
4062/*****************************************************************************
4063 * SIMPLIFYING SUBQUERY TARGETLISTS
4064 *****************************************************************************/
4065
4066/*
4067 * remove_unused_subquery_outputs
4068 * Remove subquery targetlist items we don't need
4069 *
4070 * It's possible, even likely, that the upper query does not read all the
4071 * output columns of the subquery. We can remove any such outputs that are
4072 * not needed by the subquery itself (e.g., as sort/group columns) and do not
4073 * affect semantics otherwise (e.g., volatile functions can't be removed).
4074 * This is useful not only because we might be able to remove expensive-to-
4075 * compute expressions, but because deletion of output columns might allow
4076 * optimizations such as join removal to occur within the subquery.
4077 *
4078 * extra_used_attrs can be passed as non-NULL to mark any columns (offset by
4079 * FirstLowInvalidHeapAttributeNumber) that we should not remove. This
4080 * parameter is modified by the function, so callers must make a copy if they
4081 * need to use the passed in Bitmapset after calling this function.
4082 *
4083 * To avoid affecting column numbering in the targetlist, we don't physically
4084 * remove unused tlist entries, but rather replace their expressions with NULL
4085 * constants. This is implemented by modifying subquery->targetList.
4086 */
4087static void
4088remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel,
4089 Bitmapset *extra_used_attrs)
4090{
4091 Bitmapset *attrs_used;
4092 ListCell *lc;
4093
4094 /*
4095 * Just point directly to extra_used_attrs. No need to bms_copy as none of
4096 * the current callers use the Bitmapset after calling this function.
4097 */
4098 attrs_used = extra_used_attrs;
4099
4100 /*
4101 * Do nothing if subquery has UNION/INTERSECT/EXCEPT: in principle we
4102 * could update all the child SELECTs' tlists, but it seems not worth the
4103 * trouble presently.
4104 */
4105 if (subquery->setOperations)
4106 return;
4107
4108 /*
4109 * If subquery has regular DISTINCT (not DISTINCT ON), we're wasting our
4110 * time: all its output columns must be used in the distinctClause.
4111 */
4112 if (subquery->distinctClause && !subquery->hasDistinctOn)
4113 return;
4114
4115 /*
4116 * Collect a bitmap of all the output column numbers used by the upper
4117 * query.
4118 *
4119 * Add all the attributes needed for joins or final output. Note: we must
4120 * look at rel's targetlist, not the attr_needed data, because attr_needed
4121 * isn't computed for inheritance child rels, cf set_append_rel_size().
4122 * (XXX might be worth changing that sometime.)
4123 */
4124 pull_varattnos((Node *) rel->reltarget->exprs, rel->relid, &attrs_used);
4125
4126 /* Add all the attributes used by un-pushed-down restriction clauses. */
4127 foreach(lc, rel->baserestrictinfo)
4128 {
4129 RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
4130
4131 pull_varattnos((Node *) rinfo->clause, rel->relid, &attrs_used);
4132 }
4133
4134 /*
4135 * If there's a whole-row reference to the subquery, we can't remove
4136 * anything.
4137 */
4138 if (bms_is_member(0 - FirstLowInvalidHeapAttributeNumber, attrs_used))
4139 return;
4140
4141 /*
4142 * Run through the tlist and zap entries we don't need. It's okay to
4143 * modify the tlist items in-place because set_subquery_pathlist made a
4144 * copy of the subquery.
4145 */
4146 foreach(lc, subquery->targetList)
4147 {
4148 TargetEntry *tle = (TargetEntry *) lfirst(lc);
4149 Node *texpr = (Node *) tle->expr;
4150
4151 /*
4152 * If it has a sortgroupref number, it's used in some sort/group
4153 * clause so we'd better not remove it. Also, don't remove any
4154 * resjunk columns, since their reason for being has nothing to do
4155 * with anybody reading the subquery's output. (It's likely that
4156 * resjunk columns in a sub-SELECT would always have ressortgroupref
4157 * set, but even if they don't, it seems imprudent to remove them.)
4158 */
4159 if (tle->ressortgroupref || tle->resjunk)
4160 continue;
4161
4162 /*
4163 * If it's used by the upper query, we can't remove it.
4164 */
4165 if (bms_is_member(tle->resno - FirstLowInvalidHeapAttributeNumber,
4166 attrs_used))
4167 continue;
4168
4169 /*
4170 * If it contains a set-returning function, we can't remove it since
4171 * that could change the number of rows returned by the subquery.
4172 */
4173 if (subquery->hasTargetSRFs &&
4174 expression_returns_set(texpr))
4175 continue;
4176
4177 /*
4178 * If it contains volatile functions, we daren't remove it for fear
4179 * that the user is expecting their side-effects to happen.
4180 */
4181 if (contain_volatile_functions(texpr))
4182 continue;
4183
4184 /*
4185 * OK, we don't need it. Replace the expression with a NULL constant.
4186 * Preserve the exposed type of the expression, in case something
4187 * looks at the rowtype of the subquery's result.
4188 */
4189 tle->expr = (Expr *) makeNullConst(exprType(texpr),
4190 exprTypmod(texpr),
4191 exprCollation(texpr));
4192 }
4193}
4194
4195/*
4196 * create_partial_bitmap_paths
4197 * Build partial bitmap heap path for the relation
4198 */
4199void
4200create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel,
4201 Path *bitmapqual)
4202{
4203 int parallel_workers;
4204 double pages_fetched;
4205
4206 /* Compute heap pages for bitmap heap scan */
4207 pages_fetched = compute_bitmap_pages(root, rel, bitmapqual, 1.0,
4208 NULL, NULL);
4209
4210 parallel_workers = compute_parallel_worker(rel, pages_fetched, -1,
4211 max_parallel_workers_per_gather);
4212
4213 if (parallel_workers <= 0)
4214 return;
4215
4216 add_partial_path(rel, (Path *) create_bitmap_heap_path(root, rel,
4217 bitmapqual, rel->lateral_relids, 1.0, parallel_workers));
4218}
4219
4220/*
4221 * Compute the number of parallel workers that should be used to scan a
4222 * relation. We compute the parallel workers based on the size of the heap to
4223 * be scanned and the size of the index to be scanned, then choose a minimum
4224 * of those.
4225 *
4226 * "heap_pages" is the number of pages from the table that we expect to scan, or
4227 * -1 if we don't expect to scan any.
4228 *
4229 * "index_pages" is the number of pages from the index that we expect to scan, or
4230 * -1 if we don't expect to scan any.
4231 *
4232 * "max_workers" is caller's limit on the number of workers. This typically
4233 * comes from a GUC.
4234 */
4235int
4236compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages,
4237 int max_workers)
4238{
4239 int parallel_workers = 0;
4240
4241 /*
4242 * If the user has set the parallel_workers reloption, use that; otherwise
4243 * select a default number of workers.
4244 */
4245 if (rel->rel_parallel_workers != -1)
4246 parallel_workers = rel->rel_parallel_workers;
4247 else
4248 {
4249 /*
4250 * If the number of pages being scanned is insufficient to justify a
4251 * parallel scan, just return zero ... unless it's an inheritance
4252 * child. In that case, we want to generate a parallel path here
4253 * anyway. It might not be worthwhile just for this relation, but
4254 * when combined with all of its inheritance siblings it may well pay
4255 * off.
4256 */
4257 if (rel->reloptkind == RELOPT_BASEREL &&
4258 ((heap_pages >= 0 && heap_pages < min_parallel_table_scan_size) ||
4259 (index_pages >= 0 && index_pages < min_parallel_index_scan_size)))
4260 return 0;
4261
4262 if (heap_pages >= 0)
4263 {
4264 int heap_parallel_threshold;
4265 int heap_parallel_workers = 1;
4266
4267 /*
4268 * Select the number of workers based on the log of the size of
4269 * the relation. This probably needs to be a good deal more
4270 * sophisticated, but we need something here for now. Note that
4271 * the upper limit of the min_parallel_table_scan_size GUC is
4272 * chosen to prevent overflow here.
4273 */
4274 heap_parallel_threshold = Max(min_parallel_table_scan_size, 1);
4275 while (heap_pages >= (BlockNumber) (heap_parallel_threshold * 3))
4276 {
4277 heap_parallel_workers++;
4278 heap_parallel_threshold *= 3;
4279 if (heap_parallel_threshold > INT_MAX / 3)
4280 break; /* avoid overflow */
4281 }
4282
4283 parallel_workers = heap_parallel_workers;
4284 }
4285
4286 if (index_pages >= 0)
4287 {
4288 int index_parallel_workers = 1;
4289 int index_parallel_threshold;
4290
4291 /* same calculation as for heap_pages above */
4292 index_parallel_threshold = Max(min_parallel_index_scan_size, 1);
4293 while (index_pages >= (BlockNumber) (index_parallel_threshold * 3))
4294 {
4295 index_parallel_workers++;
4296 index_parallel_threshold *= 3;
4297 if (index_parallel_threshold > INT_MAX / 3)
4298 break; /* avoid overflow */
4299 }
4300
4301 if (parallel_workers > 0)
4302 parallel_workers = Min(parallel_workers, index_parallel_workers);
4303 else
4304 parallel_workers = index_parallel_workers;
4305 }
4306 }
4307
4308 /* In no case use more than caller supplied maximum number of workers */
4309 parallel_workers = Min(parallel_workers, max_workers);
4310
4311 return parallel_workers;
4312}
4313
4314/*
4315 * generate_partitionwise_join_paths
4316 * Create paths representing partitionwise join for given partitioned
4317 * join relation.
4318 *
4319 * This must not be called until after we are done adding paths for all
4320 * child-joins. Otherwise, add_path might delete a path to which some path
4321 * generated here has a reference.
4322 */
4323void
4324generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
4325{
4326 List *live_children = NIL;
4327 int cnt_parts;
4328 int num_parts;
4329 RelOptInfo **part_rels;
4330
4331 /* Handle only join relations here. */
4332 if (!IS_JOIN_REL(rel))
4333 return;
4334
4335 /* We've nothing to do if the relation is not partitioned. */
4336 if (!IS_PARTITIONED_REL(rel))
4337 return;
4338
4339 /* The relation should have consider_partitionwise_join set. */
4340 Assert(rel->consider_partitionwise_join);
4341
4342 /* Guard against stack overflow due to overly deep partition hierarchy. */
4343 check_stack_depth();
4344
4345 num_parts = rel->nparts;
4346 part_rels = rel->part_rels;
4347
4348 /* Collect non-dummy child-joins. */
4349 for (cnt_parts = 0; cnt_parts < num_parts; cnt_parts++)
4350 {
4351 RelOptInfo *child_rel = part_rels[cnt_parts];
4352
4353 /* If it's been pruned entirely, it's certainly dummy. */
4354 if (child_rel == NULL)
4355 continue;
4356
4357 /* Make partitionwise join paths for this partitioned child-join. */
4358 generate_partitionwise_join_paths(root, child_rel);
4359
4360 /* If we failed to make any path for this child, we must give up. */
4361 if (child_rel->pathlist == NIL)
4362 {
4363 /*
4364 * Mark the parent joinrel as unpartitioned so that later
4365 * functions treat it correctly.
4366 */
4367 rel->nparts = 0;
4368 return;
4369 }
4370
4371 /* Else, identify the cheapest path for it. */
4372 set_cheapest(child_rel);
4373
4374 /* Dummy children need not be scanned, so ignore those. */
4375 if (IS_DUMMY_REL(child_rel))
4376 continue;
4377
4378#ifdef OPTIMIZER_DEBUG
4379 pprint(child_rel);
4380#endif
4381
4382 live_children = lappend(live_children, child_rel);
4383 }
4384
4385 /* If all child-joins are dummy, parent join is also dummy. */
4386 if (!live_children)
4387 {
4388 mark_dummy_rel(rel);
4389 return;
4390 }
4391
4392 /* Build additional paths for this rel from child-join paths. */
4393 add_paths_to_append_rel(root, rel, live_children);
4394 list_free(live_children);
4395}
set_base_rel_sizes
static void set_base_rel_sizes(PlannerInfo *root)
Definition: allpaths.c:290
get_useful_pathkeys_for_relation
static List * get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel, bool require_parallel_safe)
Definition: allpaths.c:3154
set_subquery_pathlist
static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:2515
find_window_run_conditions
static bool find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti, AttrNumber attno, WindowFunc *wfunc, OpExpr *opexpr, bool wfunc_left, bool *keep_original, Bitmapset **run_cond_attrs)
Definition: allpaths.c:2247
UNSAFE_TYPE_MISMATCH
#define UNSAFE_TYPE_MISMATCH
Definition: allpaths.c:57
get_cheapest_parameterized_child_path
static Path * get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: allpaths.c:2032
set_namedtuplestore_pathlist
static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2972
subquery_push_qual
static void subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
Definition: allpaths.c:3988
generate_partitionwise_join_paths
void generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: allpaths.c:4324
set_base_rel_consider_startup
static void set_base_rel_consider_startup(PlannerInfo *root)
Definition: allpaths.c:247
UNSAFE_HAS_VOLATILE_FUNC
#define UNSAFE_HAS_VOLATILE_FUNC
Definition: allpaths.c:53
UNSAFE_NOTIN_DISTINCTON_CLAUSE
#define UNSAFE_NOTIN_DISTINCTON_CLAUSE
Definition: allpaths.c:55
set_rel_pathlist
static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:469
get_singleton_append_subpath
static Path * get_singleton_append_subpath(Path *path)
Definition: allpaths.c:2165
set_tablesample_rel_size
static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:826
set_tablesample_rel_pathlist
static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:866
set_foreign_pathlist
static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:938
set_base_rel_pathlists
static void set_base_rel_pathlists(PlannerInfo *root)
Definition: allpaths.c:333
standard_join_search
RelOptInfo * standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
Definition: allpaths.c:3443
geqo_threshold
int geqo_threshold
Definition: allpaths.c:80
set_append_rel_pathlist
static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:1251
qual_is_pushdown_safe
static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3887
set_result_pathlist
static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2999
compute_parallel_worker
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition: allpaths.c:4236
generate_gather_paths
void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition: allpaths.c:3085
set_dummy_rel_pathlist
static void set_dummy_rel_pathlist(RelOptInfo *rel)
Definition: allpaths.c:2199
compare_tlist_datatypes
static void compare_tlist_datatypes(List *tlist, List *colTypes, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3811
set_worktable_pathlist
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:3026
targetIsInAllPartitionLists
static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query)
Definition: allpaths.c:3844
create_plain_partial_paths
static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: allpaths.c:806
subquery_is_pushdown_safe
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3614
join_search_hook
join_search_hook_type join_search_hook
Definition: allpaths.c:88
enable_geqo
bool enable_geqo
Definition: allpaths.c:79
check_and_push_window_quals
static bool check_and_push_window_quals(Query *subquery, RangeTblEntry *rte, Index rti, Node *clause, Bitmapset **run_cond_attrs)
Definition: allpaths.c:2440
generate_useful_gather_paths
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition: allpaths.c:3222
make_rel_from_joinlist
static RelOptInfo * make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
Definition: allpaths.c:3338
set_function_pathlist
static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2782
recurse_push_qual
static void recurse_push_qual(Node *setOp, Query *topquery, RangeTblEntry *rte, Index rti, Node *qual)
Definition: allpaths.c:4036
set_plain_rel_pathlist
static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:768
remove_unused_subquery_outputs
static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel, Bitmapset *extra_used_attrs)
Definition: allpaths.c:4088
check_output_expressions
static void check_output_expressions(Query *subquery, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3739
set_tablefunc_pathlist
static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2869
set_foreign_size
static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:914
set_rel_pathlist_hook
set_rel_pathlist_hook_type set_rel_pathlist_hook
Definition: allpaths.c:85
set_values_pathlist
static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2849
pushdown_safety_info
struct pushdown_safety_info pushdown_safety_info
make_one_rel
RelOptInfo * make_one_rel(PlannerInfo *root, List *joinlist)
Definition: allpaths.c:171
UNSAFE_HAS_SET_FUNC
#define UNSAFE_HAS_SET_FUNC
Definition: allpaths.c:54
set_cte_pathlist
static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2893
set_rel_consider_parallel
static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:589
set_append_rel_size
static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:956
create_partial_bitmap_paths
void create_partial_bitmap_paths(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual)
Definition: allpaths.c:4200
set_plain_rel_size
static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:572
add_paths_to_append_rel
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
Definition: allpaths.c:1321
set_rel_size
static void set_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:360
generate_orderedappend_paths
static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel, List *live_childrels, List *all_child_pathkeys)
Definition: allpaths.c:1747
UNSAFE_NOTIN_PARTITIONBY_CLAUSE
#define UNSAFE_NOTIN_PARTITIONBY_CLAUSE
Definition: allpaths.c:56
recurse_pushdown_safe
static bool recurse_pushdown_safe(Node *setOp, Query *topquery, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3670
pushdown_safe_type
pushdown_safe_type
Definition: allpaths.c:71
PUSHDOWN_WINDOWCLAUSE_RUNCOND
@ PUSHDOWN_WINDOWCLAUSE_RUNCOND
Definition: allpaths.c:74
PUSHDOWN_UNSAFE
@ PUSHDOWN_UNSAFE
Definition: allpaths.c:72
PUSHDOWN_SAFE
@ PUSHDOWN_SAFE
Definition: allpaths.c:73
accumulate_append_subpath
static void accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
Definition: allpaths.c:2120
min_parallel_index_scan_size
int min_parallel_index_scan_size
Definition: allpaths.c:82
min_parallel_table_scan_size
int min_parallel_table_scan_size
Definition: allpaths.c:81
adjust_appendrel_attrs
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Definition: appendinfo.c:200
AttrNumber
int16 AttrNumber
Definition: attnum.h:21
InvalidAttrNumber
#define InvalidAttrNumber
Definition: attnum.h:23
pprint
void pprint(const void *obj)
Definition: print.c:54
bms_equal
bool bms_equal(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:142
bms_is_subset
bool bms_is_subset(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:412
bms_is_member
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
bms_add_member
Bitmapset * bms_add_member(Bitmapset *a, int x)
Definition: bitmapset.c:815
bms_membership
BMS_Membership bms_membership(const Bitmapset *a)
Definition: bitmapset.c:781
bms_overlap
bool bms_overlap(const Bitmapset *a, const Bitmapset *b)
Definition: bitmapset.c:582
bms_get_singleton_member
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition: bitmapset.c:715
bms_is_empty
#define bms_is_empty(a)
Definition: bitmapset.h:118
BMS_SINGLETON
@ BMS_SINGLETON
Definition: bitmapset.h:72
BMS_MULTIPLE
@ BMS_MULTIPLE
Definition: bitmapset.h:73
BlockNumber
uint32 BlockNumber
Definition: block.h:31
Min
#define Min(x, y)
Definition: c.h:975
Max
#define Max(x, y)
Definition: c.h:969
int16
int16_t int16
Definition: c.h:497
int32
int32_t int32
Definition: c.h:498
Index
unsigned int Index
Definition: c.h:585
OidIsValid
#define OidIsValid(objectId)
Definition: c.h:746
is_pseudo_constant_clause
bool is_pseudo_constant_clause(Node *clause)
Definition: clauses.c:2088
contain_leaked_vars
bool contain_leaked_vars(Node *clause)
Definition: clauses.c:1262
is_parallel_safe
bool is_parallel_safe(PlannerInfo *root, Node *node)
Definition: clauses.c:752
contain_subplans
bool contain_subplans(Node *clause)
Definition: clauses.c:329
contain_volatile_functions
bool contain_volatile_functions(Node *clause)
Definition: clauses.c:537
set_namedtuplestore_size_estimates
void set_namedtuplestore_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6097
max_parallel_workers_per_gather
int max_parallel_workers_per_gather
Definition: costsize.c:143
set_baserel_size_estimates
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:5334
set_function_size_estimates
void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:5967
set_cte_size_estimates
void set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel, double cte_rows)
Definition: costsize.c:6059
compute_gather_rows
double compute_gather_rows(Path *path)
Definition: costsize.c:6609
set_result_size_estimates
void set_result_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6130
enable_partitionwise_join
bool enable_partitionwise_join
Definition: costsize.c:159
compute_bitmap_pages
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, double loop_count, Cost *cost_p, double *tuples_p)
Definition: costsize.c:6498
set_subquery_size_estimates
void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:5887
enable_parallel_append
bool enable_parallel_append
Definition: costsize.c:161
set_foreign_size_estimates
void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6159
clamp_row_est
double clamp_row_est(double nrows)
Definition: costsize.c:213
set_tablefunc_size_estimates
void set_tablefunc_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6005
set_values_size_estimates
void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6027
enable_incremental_sort
bool enable_incremental_sort
Definition: costsize.c:151
ERROR
#define ERROR
Definition: elog.h:39
elog
#define elog(elevel,...)
Definition: elog.h:225
add_child_rel_equivalences
void add_child_rel_equivalences(PlannerInfo *root, AppendRelInfo *appinfo, RelOptInfo *parent_rel, RelOptInfo *child_rel)
Definition: equivclass.c:2691
relation_can_be_sorted_early
bool relation_can_be_sorted_early(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, bool require_parallel_safe)
Definition: equivclass.c:922
OidFunctionCall1
#define OidFunctionCall1(functionId, arg1)
Definition: fmgr.h:679
geqo
RelOptInfo * geqo(PlannerInfo *root, int number_of_rels, List *initial_rels)
Definition: geqo_main.c:72
Assert
Assert(PointerIsAligned(start, uint64))
check_index_predicates
void check_index_predicates(PlannerInfo *root, RelOptInfo *rel)
Definition: indxpath.c:3966
create_index_paths
void create_index_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: indxpath.c:241
i
int i
Definition: isn.c:74
if
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:78
join_search_one_level
void join_search_one_level(PlannerInfo *root, int level)
Definition: joinrels.c:73
mark_dummy_rel
void mark_dummy_rel(RelOptInfo *rel)
Definition: joinrels.c:1385
lappend
List * lappend(List *list, void *datum)
Definition: list.c:339
list_copy_tail
List * list_copy_tail(const List *oldlist, int nskip)
Definition: list.c:1613
list_concat
List * list_concat(List *list1, const List *list2)
Definition: list.c:561
list_free
void list_free(List *list)
Definition: list.c:1546
list_copy_head
List * list_copy_head(const List *oldlist, int len)
Definition: list.c:1593
get_op_btree_interpretation
List * get_op_btree_interpretation(Oid opno)
Definition: lsyscache.c:624
get_rel_persistence
char get_rel_persistence(Oid relid)
Definition: lsyscache.c:2161
func_parallel
char func_parallel(Oid funcid)
Definition: lsyscache.c:1882
get_func_support
RegProcedure get_func_support(Oid funcid)
Definition: lsyscache.c:1941
get_opfamily_member
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Definition: lsyscache.c:167
func_strict
bool func_strict(Oid funcid)
Definition: lsyscache.c:1844
get_typavgwidth
int32 get_typavgwidth(Oid typid, int32 typmod)
Definition: lsyscache.c:2661
subpath
Datum subpath(PG_FUNCTION_ARGS)
Definition: ltree_op.c:308
makeNullConst
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition: makefuncs.c:388
make_and_qual
Node * make_and_qual(Node *qual1, Node *qual2)
Definition: makefuncs.c:780
pfree
void pfree(void *pointer)
Definition: mcxt.c:1524
palloc0
void * palloc0(Size size)
Definition: mcxt.c:1347
exprType
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
exprTypmod
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
exprCollation
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
expression_returns_set
bool expression_returns_set(Node *clause)
Definition: nodeFuncs.c:763
set_opfuncid
void set_opfuncid(OpExpr *opexpr)
Definition: nodeFuncs.c:1872
IsA
#define IsA(nodeptr, _type_)
Definition: nodes.h:160
copyObject
#define copyObject(obj)
Definition: nodes.h:226
nodeTag
#define nodeTag(nodeptr)
Definition: nodes.h:135
makeNode
#define makeNode(_type_)
Definition: nodes.h:157
castNode
#define castNode(_type_, nodeptr)
Definition: nodes.h:178
JOIN_SEMI
@ JOIN_SEMI
Definition: nodes.h:309
JOIN_ANTI
@ JOIN_ANTI
Definition: nodes.h:310
PVC_INCLUDE_PLACEHOLDERS
#define PVC_INCLUDE_PLACEHOLDERS
Definition: optimizer.h:191
targetIsInSortList
bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList)
Definition: parse_clause.c:3635
parse_clause.h
SETOP_EXCEPT
@ SETOP_EXCEPT
Definition: parsenodes.h:2165
RTE_JOIN
@ RTE_JOIN
Definition: parsenodes.h:1028
RTE_CTE
@ RTE_CTE
Definition: parsenodes.h:1032
RTE_NAMEDTUPLESTORE
@ RTE_NAMEDTUPLESTORE
Definition: parsenodes.h:1033
RTE_VALUES
@ RTE_VALUES
Definition: parsenodes.h:1031
RTE_SUBQUERY
@ RTE_SUBQUERY
Definition: parsenodes.h:1027
RTE_RESULT
@ RTE_RESULT
Definition: parsenodes.h:1034
RTE_FUNCTION
@ RTE_FUNCTION
Definition: parsenodes.h:1029
RTE_TABLEFUNC
@ RTE_TABLEFUNC
Definition: parsenodes.h:1030
RTE_GROUP
@ RTE_GROUP
Definition: parsenodes.h:1037
RTE_RELATION
@ RTE_RELATION
Definition: parsenodes.h:1026
rt_fetch
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
partitions_are_ordered
bool partitions_are_ordered(PartitionBoundInfo boundinfo, Bitmapset *live_parts)
Definition: partbounds.c:2852
get_cheapest_fractional_path_for_pathkeys
Path * get_cheapest_fractional_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, double fraction)
Definition: pathkeys.c:666
get_cheapest_path_for_pathkeys
Path * get_cheapest_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, CostSelector cost_criterion, bool require_parallel_safe)
Definition: pathkeys.c:620
pathkeys_count_contained_in
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
Definition: pathkeys.c:558
has_useful_pathkeys
bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
Definition: pathkeys.c:2315
build_expression_pathkey
List * build_expression_pathkey(PlannerInfo *root, Expr *expr, Oid opno, Relids rel, bool create_it)
Definition: pathkeys.c:1000
build_partition_pathkeys
List * build_partition_pathkeys(PlannerInfo *root, RelOptInfo *partrel, ScanDirection scandir, bool *partialkeys)
Definition: pathkeys.c:919
convert_subquery_pathkeys
List * convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel, List *subquery_pathkeys, List *subquery_tlist)
Definition: pathkeys.c:1054
pathkeys_contained_in
bool pathkeys_contained_in(List *keys1, List *keys2)
Definition: pathkeys.c:343
compare_pathkeys
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
Definition: pathkeys.c:304
get_cheapest_parallel_safe_total_inner
Path * get_cheapest_parallel_safe_total_inner(List *paths)
Definition: pathkeys.c:699
create_functionscan_path
Path * create_functionscan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
Definition: pathnode.c:2118
create_valuesscan_path
Path * create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2170
create_worktablescan_path
Path * create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2274
create_seqscan_path
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
Definition: pathnode.c:983
create_gather_merge_path
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
Definition: pathnode.c:1962
set_cheapest
void set_cheapest(RelOptInfo *parent_rel)
Definition: pathnode.c:269
add_partial_path
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
Definition: pathnode.c:795
create_append_path
AppendPath * create_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *partial_subpaths, List *pathkeys, Relids required_outer, int parallel_workers, bool parallel_aware, double rows)
Definition: pathnode.c:1300
create_namedtuplestorescan_path
Path * create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2222
create_subqueryscan_path
SubqueryScanPath * create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, bool trivial_pathtarget, List *pathkeys, Relids required_outer)
Definition: pathnode.c:2088
create_incremental_sort_path
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
Definition: pathnode.c:3032
create_bitmap_heap_path
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
Definition: pathnode.c:1098
create_tablefuncscan_path
Path * create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2144
create_sort_path
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
Definition: pathnode.c:3082
create_gather_path
GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
Definition: pathnode.c:2044
create_samplescan_path
Path * create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:1008
create_material_path
MaterialPath * create_material_path(RelOptInfo *rel, Path *subpath)
Definition: pathnode.c:1634
add_path
void add_path(RelOptInfo *parent_rel, Path *new_path)
Definition: pathnode.c:461
compare_path_costs
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
Definition: pathnode.c:69
create_resultscan_path
Path * create_resultscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2248
create_ctescan_path
Path * create_ctescan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
Definition: pathnode.c:2196
create_merge_append_path
MergeAppendPath * create_merge_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *pathkeys, Relids required_outer)
Definition: pathnode.c:1471
reparameterize_path
Path * reparameterize_path(PlannerInfo *root, Path *path, Relids required_outer, double loop_count)
Definition: pathnode.c:4103
IS_SIMPLE_REL
#define IS_SIMPLE_REL(rel)
Definition: pathnodes.h:866
IS_DUMMY_REL
#define IS_DUMMY_REL(r)
Definition: pathnodes.h:1985
IS_JOIN_REL
#define IS_JOIN_REL(rel)
Definition: pathnodes.h:871
TOTAL_COST
@ TOTAL_COST
Definition: pathnodes.h:38
STARTUP_COST
@ STARTUP_COST
Definition: pathnodes.h:38
IS_PARTITIONED_REL
#define IS_PARTITIONED_REL(rel)
Definition: pathnodes.h:1089
PATH_REQ_OUTER
#define PATH_REQ_OUTER(path)
Definition: pathnodes.h:1708
Relids
Bitmapset * Relids
Definition: pathnodes.h:30
UPPERREL_FINAL
@ UPPERREL_FINAL
Definition: pathnodes.h:79
RELOPT_BASEREL
@ RELOPT_BASEREL
Definition: pathnodes.h:854
RELOPT_OTHER_MEMBER_REL
@ RELOPT_OTHER_MEMBER_REL
Definition: pathnodes.h:856
set_rel_pathlist_hook_type
void(* set_rel_pathlist_hook_type)(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: paths.h:30
join_search_hook_type
RelOptInfo *(* join_search_hook_type)(PlannerInfo *root, int levels_needed, List *initial_rels)
Definition: paths.h:46
PATHKEYS_EQUAL
@ PATHKEYS_EQUAL
Definition: paths.h:207
arg
void * arg
Definition: pg_backup_utils.c:29
pg_bitutils.h
pg_leftmost_one_pos32
static int pg_leftmost_one_pos32(uint32 word)
Definition: pg_bitutils.h:41
pg_class.h
lfirst
#define lfirst(lc)
Definition: pg_list.h:172
list_length
static int list_length(const List *l)
Definition: pg_list.h:152
NIL
#define NIL
Definition: pg_list.h:68
forboth
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
foreach_current_index
#define foreach_current_index(var_or_cell)
Definition: pg_list.h:403
list_make1
#define list_make1(x1)
Definition: pg_list.h:212
for_each_from
#define for_each_from(cell, lst, N)
Definition: pg_list.h:414
list_nth
static void * list_nth(const List *list, int n)
Definition: pg_list.h:299
linitial
#define linitial(l)
Definition: pg_list.h:178
lsecond
#define lsecond(l)
Definition: pg_list.h:183
list_head
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
list_nth_node
#define list_nth_node(type, list, n)
Definition: pg_list.h:327
lnext
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
lfirst_oid
#define lfirst_oid(lc)
Definition: pg_list.h:174
list_nth_int
static int list_nth_int(const List *list, int n)
Definition: pg_list.h:310
pg_operator.h
pg_proc.h
relation_excluded_by_constraints
bool relation_excluded_by_constraints(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: plancat.c:1594
get_cheapest_fractional_path
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
Definition: planner.c:6479
subquery_planner
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction, SetOperationStmt *setops)
Definition: planner.c:643
limit_needed
bool limit_needed(Query *parse)
Definition: planner.c:2702
MONOTONICFUNC_NONE
@ MONOTONICFUNC_NONE
Definition: plannodes.h:1765
MONOTONICFUNC_DECREASING
@ MONOTONICFUNC_DECREASING
Definition: plannodes.h:1767
MONOTONICFUNC_INCREASING
@ MONOTONICFUNC_INCREASING
Definition: plannodes.h:1766
MONOTONICFUNC_BOTH
@ MONOTONICFUNC_BOTH
Definition: plannodes.h:1768
PointerGetDatum
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
DatumGetPointer
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
InvalidOid
#define InvalidOid
Definition: postgres_ext.h:37
Oid
unsigned int Oid
Definition: postgres_ext.h:32
root
tree ctl root
Definition: radixtree.h:1857
parse
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:717
find_base_rel
RelOptInfo * find_base_rel(PlannerInfo *root, int relid)
Definition: relnode.c:414
fetch_upper_rel
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition: relnode.c:1458
ReplaceVarsFromTargetList
Node * ReplaceVarsFromTargetList(Node *node, int target_varno, int sublevels_up, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno, bool *outer_hasSubLinks)
Definition: rewriteManip.c:2005
REPLACEVARS_REPORT_ERROR
@ REPLACEVARS_REPORT_ERROR
Definition: rewriteManip.h:39
BackwardScanDirection
@ BackwardScanDirection
Definition: sdir.h:26
ForwardScanDirection
@ ForwardScanDirection
Definition: sdir.h:28
check_stack_depth
void check_stack_depth(void)
Definition: stack_depth.c:95
BTGreaterStrategyNumber
#define BTGreaterStrategyNumber
Definition: stratnum.h:33
BTLessStrategyNumber
#define BTLessStrategyNumber
Definition: stratnum.h:29
BTEqualStrategyNumber
#define BTEqualStrategyNumber
Definition: stratnum.h:31
BTLessEqualStrategyNumber
#define BTLessEqualStrategyNumber
Definition: stratnum.h:30
BTGreaterEqualStrategyNumber
#define BTGreaterEqualStrategyNumber
Definition: stratnum.h:32
AppendPath::first_partial_path
int first_partial_path
Definition: pathnodes.h:1973
AppendPath::subpaths
List * subpaths
Definition: pathnodes.h:1971
AppendRelInfo::child_relid
Index child_relid
Definition: pathnodes.h:3008
AppendRelInfo::parent_relid
Index parent_relid
Definition: pathnodes.h:3007
FromExpr::quals
Node * quals
Definition: primnodes.h:2338
List
Definition: pg_list.h:54
Node
Definition: nodes.h:131
OpExpr::opno
Oid opno
Definition: primnodes.h:835
OpExpr::args
List * args
Definition: primnodes.h:853
PathTarget::exprs
List * exprs
Definition: pathnodes.h:1571
Path::pathkeys
List * pathkeys
Definition: pathnodes.h:1704
Path::rows
Cardinality rows
Definition: pathnodes.h:1698
Path::parallel_workers
int parallel_workers
Definition: pathnodes.h:1695
Path::total_cost
Cost total_cost
Definition: pathnodes.h:1701
Path::parallel_aware
bool parallel_aware
Definition: pathnodes.h:1691
Plan::plan_rows
Cardinality plan_rows
Definition: plannodes.h:182
Plan::targetlist
List * targetlist
Definition: plannodes.h:206
PlannerInfo::cte_plan_ids
List * cte_plan_ids
Definition: pathnodes.h:329
PlannerInfo::non_recursive_path
struct Path * non_recursive_path
Definition: pathnodes.h:562
PlannerInfo::parse
Query * parse
Definition: pathnodes.h:226
Query::limitCount
Node * limitCount
Definition: parsenodes.h:225
Query::jointree
FromExpr * jointree
Definition: parsenodes.h:177
Query::setOperations
Node * setOperations
Definition: parsenodes.h:230
Query::cteList
List * cteList
Definition: parsenodes.h:168
Query::groupClause
List * groupClause
Definition: parsenodes.h:211
Query::havingQual
Node * havingQual
Definition: parsenodes.h:216
Query::rtable
List * rtable
Definition: parsenodes.h:170
Query::limitOffset
Node * limitOffset
Definition: parsenodes.h:224
Query::windowClause
List * windowClause
Definition: parsenodes.h:218
Query::targetList
List * targetList
Definition: parsenodes.h:193
Query::groupingSets
List * groupingSets
Definition: parsenodes.h:214
Query::distinctClause
List * distinctClause
Definition: parsenodes.h:220
RangeTblEntry::ctename
char * ctename
Definition: parsenodes.h:1205
RangeTblEntry::ctelevelsup
Index ctelevelsup
Definition: parsenodes.h:1207
RangeTblEntry::funcordinality
bool funcordinality
Definition: parsenodes.h:1188
RangeTblEntry::tablesample
struct TableSampleClause * tablesample
Definition: parsenodes.h:1107
RangeTblEntry::subquery
Query * subquery
Definition: parsenodes.h:1113
RangeTblEntry::values_lists
List * values_lists
Definition: parsenodes.h:1199
RangeTblEntry::functions
List * functions
Definition: parsenodes.h:1186
RangeTblEntry::rtekind
RTEKind rtekind
Definition: parsenodes.h:1056
RelOptInfo::baserestrictinfo
List * baserestrictinfo
Definition: pathnodes.h:1012
RelOptInfo::consider_param_startup
bool consider_param_startup
Definition: pathnodes.h:912
RelOptInfo::subplan_params
List * subplan_params
Definition: pathnodes.h:981
RelOptInfo::joininfo
List * joininfo
Definition: pathnodes.h:1018
RelOptInfo::relids
Relids relids
Definition: pathnodes.h:898
RelOptInfo::reltarget
struct PathTarget * reltarget
Definition: pathnodes.h:920
RelOptInfo::relid
Index relid
Definition: pathnodes.h:945
RelOptInfo::tuples
Cardinality tuples
Definition: pathnodes.h:976
RelOptInfo::consider_parallel
bool consider_parallel
Definition: pathnodes.h:914
RelOptInfo::pages
BlockNumber pages
Definition: pathnodes.h:975
RelOptInfo::lateral_relids
Relids lateral_relids
Definition: pathnodes.h:940
RelOptInfo::pathlist
List * pathlist
Definition: pathnodes.h:925
RelOptInfo::reloptkind
RelOptKind reloptkind
Definition: pathnodes.h:892
RelOptInfo::cheapest_startup_path
struct Path * cheapest_startup_path
Definition: pathnodes.h:928
RelOptInfo::cheapest_total_path
struct Path * cheapest_total_path
Definition: pathnodes.h:929
RelOptInfo::has_eclass_joins
bool has_eclass_joins
Definition: pathnodes.h:1020
RelOptInfo::consider_startup
bool consider_startup
Definition: pathnodes.h:910
RelOptInfo::live_parts
Bitmapset * live_parts
Definition: pathnodes.h:1066
RelOptInfo::rel_parallel_workers
int rel_parallel_workers
Definition: pathnodes.h:983
RelOptInfo::consider_partitionwise_join
bool consider_partitionwise_join
Definition: pathnodes.h:1026
RelOptInfo::partial_pathlist
List * partial_pathlist
Definition: pathnodes.h:927
RelOptInfo::subroot
PlannerInfo * subroot
Definition: pathnodes.h:980
RelOptInfo::max_attr
AttrNumber max_attr
Definition: pathnodes.h:953
RelOptInfo::nulling_relids
Relids nulling_relids
Definition: pathnodes.h:965
RelOptInfo::rows
Cardinality rows
Definition: pathnodes.h:904
RelOptInfo::min_attr
AttrNumber min_attr
Definition: pathnodes.h:951
RelOptInfo::rtekind
RTEKind rtekind
Definition: pathnodes.h:949
RestrictInfo::clause
Expr * clause
Definition: pathnodes.h:2602
SetOperationStmt::op
SetOperation op
Definition: parsenodes.h:2242
SpecialJoinInfo::jointype
JoinType jointype
Definition: pathnodes.h:2936
SpecialJoinInfo::syn_righthand
Relids syn_righthand
Definition: pathnodes.h:2935
SupportRequestWFuncMonotonic::window_clause
struct WindowClause * window_clause
Definition: supportnodes.h:296
SupportRequestWFuncMonotonic::monotonic
MonotonicFunction monotonic
Definition: supportnodes.h:299
TargetEntry::expr
Expr * expr
Definition: primnodes.h:2219
TargetEntry::resno
AttrNumber resno
Definition: primnodes.h:2221
TargetEntry::ressortgroupref
Index ressortgroupref
Definition: primnodes.h:2225
TsmRoutine::repeatable_across_scans
bool repeatable_across_scans
Definition: tsmapi.h:65
TsmRoutine::SampleScanGetSampleSize
SampleScanGetSampleSize_function SampleScanGetSampleSize
Definition: tsmapi.h:68
Var
Definition: primnodes.h:262
Var::varattno
AttrNumber varattno
Definition: primnodes.h:274
Var::varno
int varno
Definition: primnodes.h:269
Var::varlevelsup
Index varlevelsup
Definition: primnodes.h:294
WindowClause::partitionClause
List * partitionClause
Definition: parsenodes.h:1552
WindowFunc::winref
Index winref
Definition: primnodes.h:598
WindowFunc::winfnoid
Oid winfnoid
Definition: primnodes.h:584
pushdown_safety_info
Definition: allpaths.c:61
pushdown_safety_info::unsafeFlags
unsigned char * unsafeFlags
Definition: allpaths.c:62
pushdown_safety_info::unsafeVolatile
bool unsafeVolatile
Definition: allpaths.c:65
pushdown_safety_info::unsafeLeaky
bool unsafeLeaky
Definition: allpaths.c:66
vars
Definition: regcomp.c:282
FirstLowInvalidHeapAttributeNumber
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
GetTsmRoutine
TsmRoutine * GetTsmRoutine(Oid tsmhandler)
Definition: tablesample.c:27
create_tidscan_paths
bool create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: tidpath.c:498
make_tlist_from_pathtarget
List * make_tlist_from_pathtarget(PathTarget *target)
Definition: tlist.c:624
pull_var_clause
List * pull_var_clause(Node *node, int flags)
Definition: var.c:653
pull_varattnos
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)
Definition: var.c:296