Loading...
Searching...
No Matches
allpaths.c File Reference
#include "postgres.h"#include <limits.h>#include <math.h>#include "access/sysattr.h"#include "access/tsmapi.h"#include "catalog/pg_class.h"#include "catalog/pg_operator.h"#include "catalog/pg_proc.h"#include "foreign/fdwapi.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "nodes/supportnodes.h"#include "optimizer/appendinfo.h"#include "optimizer/clauses.h"#include "optimizer/cost.h"#include "optimizer/geqo.h"#include "optimizer/optimizer.h"#include "optimizer/pathnode.h"#include "optimizer/paths.h"#include "optimizer/plancat.h"#include "optimizer/planner.h"#include "optimizer/prep.h"#include "optimizer/tlist.h"#include "parser/parse_clause.h"#include "parser/parsetree.h"#include "partitioning/partbounds.h"#include "port/pg_bitutils.h"#include "rewrite/rewriteManip.h"#include "utils/lsyscache.h"#include "utils/selfuncs.h"
Include dependency graph for allpaths.c:
Go to the source code of this file.
Data Structures | |
| struct | pushdown_safety_info |
Macros | |
| #define | UNSAFE_HAS_VOLATILE_FUNC (1 << 0) |
| #define | UNSAFE_HAS_SET_FUNC (1 << 1) |
| #define | UNSAFE_NOTIN_DISTINCTON_CLAUSE (1 << 2) |
| #define | UNSAFE_NOTIN_PARTITIONBY_CLAUSE (1 << 3) |
| #define | UNSAFE_TYPE_MISMATCH (1 << 4) |
Typedefs | |
| typedef struct pushdown_safety_info | pushdown_safety_info |
| typedef enum pushdown_safe_type | pushdown_safe_type |
Enumerations | |
| enum | pushdown_safe_type { PUSHDOWN_UNSAFE , PUSHDOWN_SAFE , PUSHDOWN_WINDOWCLAUSE_RUNCOND } |
Macro Definition Documentation
◆ UNSAFE_HAS_SET_FUNC
| #define UNSAFE_HAS_SET_FUNC (1 << 1) |
Definition at line 56 of file allpaths.c.
◆ UNSAFE_HAS_VOLATILE_FUNC
| #define UNSAFE_HAS_VOLATILE_FUNC (1 << 0) |
Definition at line 55 of file allpaths.c.
◆ UNSAFE_NOTIN_DISTINCTON_CLAUSE
| #define UNSAFE_NOTIN_DISTINCTON_CLAUSE (1 << 2) |
Definition at line 57 of file allpaths.c.
◆ UNSAFE_NOTIN_PARTITIONBY_CLAUSE
| #define UNSAFE_NOTIN_PARTITIONBY_CLAUSE (1 << 3) |
Definition at line 58 of file allpaths.c.
◆ UNSAFE_TYPE_MISMATCH
| #define UNSAFE_TYPE_MISMATCH (1 << 4) |
Definition at line 59 of file allpaths.c.
Typedef Documentation
◆ pushdown_safe_type
◆ pushdown_safety_info
Enumeration Type Documentation
◆ pushdown_safe_type
| Enumerator | |
|---|---|
| PUSHDOWN_UNSAFE | |
| PUSHDOWN_SAFE | |
| PUSHDOWN_WINDOWCLAUSE_RUNCOND | |
Definition at line 72 of file allpaths.c.
Function Documentation
◆ accumulate_append_subpath()
|
static |
Definition at line 2226 of file allpaths.c.
2227{
2229 {
2231
2233 {
2235 return;
2236 }
2238 {
2240
2241 /* Split Parallel Append into partial and non-partial subpaths */
2242 *subpaths = list_concat(*subpaths,
2244 apath->first_partial_path));
2246 apath->first_partial_path);
2248 new_special_subpaths);
2249 return;
2250 }
2251 }
2253 {
2255
2257 return;
2258 }
2259
2260 *subpaths = lappend(*subpaths, path);
2261}
Definition pathnodes.h:2256
Definition pg_list.h:54
Definition pathnodes.h:2280
References fb(), IsA, lappend(), list_concat(), list_copy_head(), and list_copy_tail().
Referenced by add_paths_to_append_rel(), and generate_orderedappend_paths().
◆ add_paths_to_append_rel()
| void add_paths_to_append_rel | ( | PlannerInfo * | root, |
| RelOptInfo * | rel, | ||
| List * | live_childrels | ||
| ) |
Definition at line 1404 of file allpaths.c.
1406{
1418 ListCell *l;
1420
1421 /* If appropriate, consider parallel append */
1423
1424 /*
1425 * For every non-dummy child, remember the cheapest path. Also, identify
1426 * all pathkeys (orderings) and parameterizations (required_outer sets)
1427 * available for the non-dummy member relations.
1428 */
1430 {
1434
1435 /*
1436 * If child has an unparameterized cheapest-total path, add that to
1437 * the unparameterized Append path we are constructing for the parent.
1438 * If not, there's no workable unparameterized path.
1439 *
1440 * With partitionwise aggregates, the child rel's pathlist may be
1441 * empty, so don't assume that a path exists here.
1442 */
1446 &subpaths, NULL);
1447 else
1449
1450 /*
1451 * When the planner is considering cheap startup plans, we'll also
1452 * collect all the cheapest_startup_paths (if set) and build an
1453 * AppendPath containing those as subpaths.
1454 */
1456 {
1458
1459 /*
1460 * With an indication of how many tuples the query should provide,
1461 * the optimizer tries to choose the path optimal for that
1462 * specific number of tuples.
1463 */
1465 cheapest_path =
1467 root->tuple_fraction);
1468 else
1470
1471 /* cheapest_startup_path must not be a parameterized path. */
1474 &startup_subpaths,
1475 NULL);
1476 }
1477 else
1479
1480
1481 /* Same idea, but for a partial plan. */
1483 {
1487 }
1488 else
1490
1491 /*
1492 * Same idea, but for a parallel append mixing partial and non-partial
1493 * paths.
1494 */
1496 {
1498
1499 nppath =
1501
1503 {
1504 /* Neither a partial nor a parallel-safe path? Forget it. */
1506 }
1510 {
1511 /* Partial path is cheaper or the only option. */
1514 &pa_partial_subpaths,
1515 &pa_nonpartial_subpaths);
1516 }
1517 else
1518 {
1519 /*
1520 * Either we've got only a non-partial path, or we think that
1521 * a single backend can execute the best non-partial path
1522 * faster than all the parallel backends working together can
1523 * execute the best partial path.
1524 *
1525 * It might make sense to be more aggressive here. Even if
1526 * the best non-partial path is more expensive than the best
1527 * partial path, it could still be better to choose the
1528 * non-partial path if there are several such paths that can
1529 * be given to different workers. For now, we don't try to
1530 * figure that out.
1531 */
1533 &pa_nonpartial_subpaths,
1534 NULL);
1535 }
1536 }
1537
1538 /*
1539 * Collect lists of all the available path orderings and
1540 * parameterizations for all the children. We use these as a
1541 * heuristic to indicate which sort orderings and parameterizations we
1542 * should build Append and MergeAppend paths for.
1543 */
1545 {
1549
1550 /* Unsorted paths don't contribute to pathkey list */
1552 {
1554 bool found = false;
1555
1556 /* Have we already seen this ordering? */
1558 {
1560
1563 {
1564 found = true;
1565 break;
1566 }
1567 }
1568 if (!found)
1569 {
1570 /* No, so add it to all_child_pathkeys */
1572 childkeys);
1573 }
1574 }
1575
1576 /* Unparameterized paths don't contribute to param-set list */
1578 {
1580 bool found = false;
1581
1582 /* Have we already seen this param set? */
1584 {
1586
1588 {
1589 found = true;
1590 break;
1591 }
1592 }
1593 if (!found)
1594 {
1595 /* No, so add it to all_child_outers */
1597 childouter);
1598 }
1599 }
1600 }
1601 }
1602
1603 /*
1604 * If we found unparameterized paths for all children, build an unordered,
1605 * unparameterized Append path for the rel. (Note: this is correct even
1606 * if we have zero or one live subpath due to constraint exclusion.)
1607 */
1611 -1));
1612
1613 /* build an AppendPath for the cheap startup paths, if valid */
1617
1618 /*
1619 * Consider an append of unordered, unparameterized partial paths. Make
1620 * it parallel-aware if possible.
1621 */
1623 {
1626 int parallel_workers = 0;
1627
1628 /* Find the highest number of workers requested for any subpath. */
1630 {
1632
1634 }
1635 Assert(parallel_workers > 0);
1636
1637 /*
1638 * If the use of parallel append is permitted, always request at least
1639 * log2(# of children) workers. We assume it can be useful to have
1640 * extra workers in this case because they will be spread out across
1641 * the children. The precise formula is just a guess, but we don't
1642 * want to end up with a radically different answer for a table with N
1643 * partitions vs. an unpartitioned table with the same data, so the
1644 * use of some kind of log-scaling here seems to make some sense.
1645 */
1647 {
1648 parallel_workers = Max(parallel_workers,
1650 parallel_workers = Min(parallel_workers,
1652 }
1653 Assert(parallel_workers > 0);
1654
1655 /* Generate a partial append path. */
1658 enable_parallel_append,
1659 -1);
1660
1661 /*
1662 * Make sure any subsequent partial paths use the same row count
1663 * estimate.
1664 */
1666
1667 /* Add the path. */
1669 }
1670
1671 /*
1672 * Consider a parallel-aware append using a mix of partial and non-partial
1673 * paths. (This only makes sense if there's at least one child which has
1674 * a non-partial path that is substantially cheaper than any partial path;
1675 * otherwise, we should use the append path added in the previous step.)
1676 */
1678 {
1681 int parallel_workers = 0;
1682
1683 /*
1684 * Find the highest number of workers requested for any partial
1685 * subpath.
1686 */
1688 {
1690
1692 }
1693
1694 /*
1695 * Same formula here as above. It's even more important in this
1696 * instance because the non-partial paths won't contribute anything to
1697 * the planned number of parallel workers.
1698 */
1699 parallel_workers = Max(parallel_workers,
1701 parallel_workers = Min(parallel_workers,
1703 Assert(parallel_workers > 0);
1704
1706 pa_partial_subpaths,
1708 partial_rows);
1710 }
1711
1712 /*
1713 * Also build unparameterized ordered append paths based on the collected
1714 * list of child pathkeys.
1715 */
1718 all_child_pathkeys);
1719
1720 /*
1721 * Build Append paths for each parameterization seen among the child rels.
1722 * (This may look pretty expensive, but in most cases of practical
1723 * interest, the child rels will expose mostly the same parameterizations,
1724 * so that not that many cases actually get considered here.)
1725 *
1726 * The Append node itself cannot enforce quals, so all qual checking must
1727 * be done in the child paths. This means that to have a parameterized
1728 * Append path, we must have the exact same parameterization for each
1729 * child path; otherwise some children might be failing to check the
1730 * moved-down quals. To make them match up, we can try to increase the
1731 * parameterization of lesser-parameterized paths.
1732 */
1734 {
1737
1738 /* Select the child paths for an Append with this parameterization */
1739 subpaths = NIL;
1742 {
1745
1747 {
1748 /* failed to make a suitable path for this child */
1750 break;
1751 }
1752
1754 childrel,
1755 required_outer);
1757 {
1758 /* failed to make a suitable path for this child */
1760 break;
1761 }
1763 }
1764
1769 -1));
1770 }
1771
1772 /*
1773 * When there is only a single child relation, the Append path can inherit
1774 * any ordering available for the child rel's path, so that it's useful to
1775 * consider ordered partial paths. Above we only considered the cheapest
1776 * partial path for each child, but let's also make paths using any
1777 * partial paths that have pathkeys.
1778 */
1780 {
1782
1783 /* skip the cheapest partial path, since we already used that above */
1785 {
1788
1789 /* skip paths with no pathkeys. */
1791 continue;
1792
1796 partial_rows);
1798 }
1799 }
1800}
static Path * get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition allpaths.c:2138
static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel, List *live_childrels, List *all_child_pathkeys)
Definition allpaths.c:1832
static void accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
Definition allpaths.c:2226
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
Definition pathkeys.c:304
Path * get_cheapest_parallel_safe_total_inner(List *paths)
Definition pathkeys.c:699
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
Definition pathnode.c:793
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:1299
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
Definition planner.c:6655
Definition bitmapset.h:50
Definition pathnodes.h:1945
Definition pathnodes.h:992
Definition pg_list.h:46
References accumulate_append_subpath(), add_partial_path(), add_path(), Assert, bms_equal(), compare_pathkeys(), RelOptInfo::consider_parallel, RelOptInfo::consider_startup, create_append_path(), enable_parallel_append, fb(), for_each_from, generate_orderedappend_paths(), get_cheapest_fractional_path(), get_cheapest_parallel_safe_total_inner(), get_cheapest_parameterized_child_path(), lappend(), lfirst, linitial, list_length(), list_make1, Max, max_parallel_workers_per_gather, Min, NIL, Path::parallel_workers, PATH_REQ_OUTER, Path::pathkeys, PATHKEYS_EQUAL, pg_leftmost_one_pos32(), root, and subpath().
Referenced by apply_scanjoin_target_to_paths(), create_partitionwise_grouping_paths(), generate_partitionwise_join_paths(), and set_append_rel_pathlist().
◆ check_and_push_window_quals()
|
static |
Definition at line 2543 of file allpaths.c.
2545{
2550
2551 /* We're only able to use OpExprs with 2 operands */
2553 return true;
2554
2556 return true;
2557
2558 /*
2559 * Currently, we restrict this optimization to strict OpExprs. The reason
2560 * for this is that during execution, once the runcondition becomes false,
2561 * we stop evaluating WindowFuncs. To avoid leaving around stale window
2562 * function result values, we set them to NULL. Having only strict
2563 * OpExprs here ensures that we properly filter out the tuples with NULLs
2564 * in the top-level WindowAgg.
2565 */
2566 set_opfuncid(opexpr);
2568 return true;
2569
2570 /*
2571 * Check for plain Vars that reference window functions in the subquery.
2572 * If we find any, we'll ask find_window_run_conditions() if 'opexpr' can
2573 * be used as part of the run condition.
2574 */
2575
2576 /* Check the left side of the OpExpr */
2579 {
2582
2586 }
2587
2588 /* and check the right side */
2591 {
2594
2598 }
2599
2600 return true;
2601}
static bool find_window_run_conditions(Query *subquery, AttrNumber attno, WindowFunc *wfunc, OpExpr *opexpr, bool wfunc_left, bool *keep_original, Bitmapset **run_cond_attrs)
Definition allpaths.c:2353
Definition primnodes.h:846
Definition primnodes.h:2236
Definition primnodes.h:262
Definition primnodes.h:594
References OpExpr::args, fb(), find_window_run_conditions(), func_strict(), IsA, linitial, list_length(), list_nth(), lsecond, set_opfuncid(), and Query::targetList.
Referenced by set_subquery_pathlist().
◆ check_output_expressions()
|
static |
Definition at line 4205 of file allpaths.c.
4206{
4209
4210 /*
4211 * We must be careful with grouping Vars and join alias Vars in the
4212 * subquery's outputs, as they hide the underlying expressions.
4213 *
4214 * We need to expand grouping Vars to their underlying expressions (the
4215 * grouping clauses) because the grouping expressions themselves might be
4216 * volatile or set-returning. However, we do not need to expand join
4217 * alias Vars, as their underlying structure does not introduce volatile
4218 * or set-returning functions at the current level.
4219 *
4220 * In neither case do we need to recursively examine the Vars contained in
4221 * these underlying expressions. Even if they reference outputs from
4222 * lower-level subqueries (at any depth), those references are guaranteed
4223 * not to expand to volatile or set-returning functions, because
4224 * subqueries containing such functions in their targetlists are never
4225 * pulled up.
4226 */
4227 if (subquery->hasGroupRTE)
4228 {
4231 }
4232
4234 {
4236
4238 continue; /* ignore resjunk columns */
4239
4240 /* Functions returning sets are unsafe (point 1) */
4241 if (subquery->hasTargetSRFs &&
4243 UNSAFE_HAS_SET_FUNC) == 0 &&
4245 {
4247 continue;
4248 }
4249
4250 /* Volatile functions are unsafe (point 2) */
4252 UNSAFE_HAS_VOLATILE_FUNC) == 0 &&
4254 {
4256 continue;
4257 }
4258
4259 /* If subquery uses DISTINCT ON, check point 3 */
4260 if (subquery->hasDistinctOn &&
4262 UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
4264 {
4265 /* non-DISTINCT column, so mark it unsafe */
4267 continue;
4268 }
4269
4270 /* If subquery uses window functions, check point 4 */
4271 if (subquery->hasWindowFuncs &&
4273 UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
4275 {
4276 /* not present in all PARTITION BY clauses, so mark it unsafe */
4278 continue;
4279 }
4280 }
4281}
static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query)
Definition allpaths.c:4334
bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList)
Definition parse_clause.c:3703
Definition nodes.h:135
Node * flatten_group_exprs(PlannerInfo *root, Query *query, Node *node)
Definition var.c:972
References contain_volatile_functions(), Query::distinctClause, expression_returns_set(), fb(), flatten_group_exprs(), InvalidOid, lfirst, targetIsInAllPartitionLists(), targetIsInSortList(), Query::targetList, UNSAFE_HAS_SET_FUNC, UNSAFE_HAS_VOLATILE_FUNC, UNSAFE_NOTIN_DISTINCTON_CLAUSE, and UNSAFE_NOTIN_PARTITIONBY_CLAUSE.
Referenced by subquery_is_pushdown_safe().
◆ compare_tlist_datatypes()
|
static |
Definition at line 4301 of file allpaths.c.
4303{
4304 ListCell *l;
4306
4307 foreach(l, tlist)
4308 {
4310
4312 continue; /* ignore resjunk columns */
4318 }
4321}
References elog, ERROR, exprType(), fb(), lfirst, lfirst_oid, list_head(), lnext(), and UNSAFE_TYPE_MISMATCH.
Referenced by subquery_is_pushdown_safe().
◆ compute_parallel_worker()
| int compute_parallel_worker | ( | RelOptInfo * | rel, |
| double | heap_pages, | ||
| double | index_pages, | ||
| int | max_workers | ||
| ) |
Definition at line 4726 of file allpaths.c.
4728{
4729 int parallel_workers = 0;
4730
4731 /*
4732 * If the user has set the parallel_workers reloption, use that; otherwise
4733 * select a default number of workers.
4734 */
4736 parallel_workers = rel->rel_parallel_workers;
4737 else
4738 {
4739 /*
4740 * If the number of pages being scanned is insufficient to justify a
4741 * parallel scan, just return zero ... unless it's an inheritance
4742 * child. In that case, we want to generate a parallel path here
4743 * anyway. It might not be worthwhile just for this relation, but
4744 * when combined with all of its inheritance siblings it may well pay
4745 * off.
4746 */
4750 return 0;
4751
4753 {
4756
4757 /*
4758 * Select the number of workers based on the log of the size of
4759 * the relation. This probably needs to be a good deal more
4760 * sophisticated, but we need something here for now. Note that
4761 * the upper limit of the min_parallel_table_scan_size GUC is
4762 * chosen to prevent overflow here.
4763 */
4766 {
4767 heap_parallel_workers++;
4768 heap_parallel_threshold *= 3;
4770 break; /* avoid overflow */
4771 }
4772
4773 parallel_workers = heap_parallel_workers;
4774 }
4775
4777 {
4780
4781 /* same calculation as for heap_pages above */
4784 {
4785 index_parallel_workers++;
4786 index_parallel_threshold *= 3;
4788 break; /* avoid overflow */
4789 }
4790
4791 if (parallel_workers > 0)
4793 else
4794 parallel_workers = index_parallel_workers;
4795 }
4796 }
4797
4798 /* In no case use more than caller supplied maximum number of workers */
4800
4801 return parallel_workers;
4802}
References fb(), Max, Min, min_parallel_index_scan_size, min_parallel_table_scan_size, RelOptInfo::rel_parallel_workers, RELOPT_BASEREL, and RelOptInfo::reloptkind.
Referenced by cost_index(), create_partial_bitmap_paths(), create_plain_partial_paths(), create_tidscan_paths(), and plan_create_index_workers().
◆ create_partial_bitmap_paths()
| void create_partial_bitmap_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | rel, | ||
| Path * | bitmapqual | ||
| ) |
Definition at line 4690 of file allpaths.c.
4692{
4693 int parallel_workers;
4695
4696 /* Compute heap pages for bitmap heap scan */
4699
4702
4703 if (parallel_workers <= 0)
4704 return;
4705
4707 bitmapqual, rel->lateral_relids, 1.0, parallel_workers));
4708}
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition allpaths.c:4726
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, double loop_count, Cost *cost_p, double *tuples_p)
Definition costsize.c:6661
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
Definition pathnode.c:1096
References add_partial_path(), compute_bitmap_pages(), compute_parallel_worker(), create_bitmap_heap_path(), fb(), RelOptInfo::lateral_relids, max_parallel_workers_per_gather, and root.
Referenced by create_index_paths().
◆ create_plain_partial_paths()
|
static |
Definition at line 860 of file allpaths.c.
861{
862 int parallel_workers;
863
866
867 /* If any limit was set to zero, the user doesn't want a parallel scan. */
868 if (parallel_workers <= 0)
869 return;
870
871 /* Add an unordered partial path based on a parallel sequential scan. */
873}
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
Definition pathnode.c:981
References add_partial_path(), compute_parallel_worker(), create_seqscan_path(), fb(), max_parallel_workers_per_gather, RelOptInfo::pages, and root.
Referenced by set_plain_rel_pathlist().
◆ find_window_run_conditions()
|
static |
Definition at line 2353 of file allpaths.c.
2356{
2360 SupportRequestWFuncMonotonic *res;
2366
2368
2371
2372 /* we can only work with window functions */
2374 return false;
2375
2376 /* can't use it if there are subplans in the WindowFunc */
2378 return false;
2379
2381
2382 /* Check if there's a support function for 'wfunc' */
2384 return false;
2385
2386 /* get the Expr from the other side of the OpExpr */
2387 if (wfunc_left)
2389 else
2391
2392 /*
2393 * The value being compared must not change during the evaluation of the
2394 * window partition.
2395 */
2397 return false;
2398
2399 /* find the window clause belonging to the window function */
2401 wfunc->winref - 1);
2402
2404 req.window_func = wfunc;
2406
2407 /* call the support function */
2408 res = (SupportRequestWFuncMonotonic *)
2411
2412 /*
2413 * Nothing to do if the function is neither monotonically increasing nor
2414 * monotonically decreasing.
2415 */
2417 return false;
2418
2422
2424 {
2427
2428 /* handle < / <= */
2430 {
2431 /*
2432 * < / <= is supported for monotonically increasing functions in
2433 * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
2434 * for monotonically decreasing functions.
2435 */
2438 {
2440 runopexpr = opexpr;
2442 }
2443 break;
2444 }
2445 /* handle > / >= */
2447 {
2448 /*
2449 * > / >= is supported for monotonically decreasing functions in
2450 * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
2451 * for monotonically increasing functions.
2452 */
2455 {
2457 runopexpr = opexpr;
2459 }
2460 break;
2461 }
2462 /* handle = */
2464 {
2466
2467 /*
2468 * When both monotonically increasing and decreasing then the
2469 * return value of the window function will be the same each time.
2470 * We can simply use 'opexpr' as the run condition without
2471 * modifying it.
2472 */
2474 {
2476 runopexpr = opexpr;
2478 break;
2479 }
2480
2481 /*
2482 * When monotonically increasing we make a qual with <wfunc> <=
2483 * <value> or <value> >= <wfunc> in order to filter out values
2484 * which are above the value in the equality condition. For
2485 * monotonically decreasing functions we want to filter values
2486 * below the value in the equality condition.
2487 */
2490 else
2492
2493 /* We must keep the original equality qual */
2495 runopexpr = opexpr;
2496
2497 /* determine the operator to use for the WindowFuncRunCondition */
2499 opinfo->oplefttype,
2500 opinfo->oprighttype,
2501 newcmptype);
2502 break;
2503 }
2504 }
2505
2507 {
2509
2513 wfuncrc->wfunc_left = wfunc_left;
2515
2517
2518 /* record that this attno was used in a run condition */
2520 attno - FirstLowInvalidHeapAttributeNumber);
2521 return true;
2522 }
2523
2524 /* unsupported OpExpr */
2525 return false;
2526}
Oid get_opfamily_member_for_cmptype(Oid opfamily, Oid lefttype, Oid righttype, CompareType cmptype)
Definition lsyscache.c:197
Definition primnodes.h:189
Definition lsyscache.h:26
Definition primnodes.h:1215
Definition parsenodes.h:1595
Definition primnodes.h:629
References arg, OpExpr::args, bms_add_member(), OpIndexInterpretation::cmptype, COMPARE_EQ, COMPARE_GE, COMPARE_GT, COMPARE_LE, COMPARE_LT, contain_subplans(), copyObject, DatumGetPointer(), fb(), FirstLowInvalidHeapAttributeNumber, get_func_support(), get_op_index_interpretation(), get_opfamily_member_for_cmptype(), InvalidOid, is_pseudo_constant_clause(), IsA, lappend(), lfirst, linitial, list_nth(), lsecond, makeNode, SupportRequestWFuncMonotonic::monotonic, MONOTONICFUNC_BOTH, MONOTONICFUNC_DECREASING, MONOTONICFUNC_INCREASING, MONOTONICFUNC_NONE, OidFunctionCall1, OidIsValid, OpExpr::opno, PointerGetDatum(), Query::windowClause, WindowFunc::winfnoid, and WindowFunc::winref.
Referenced by check_and_push_window_quals().
◆ generate_gather_paths()
| void generate_gather_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | rel, | ||
| bool | override_rows | ||
| ) |
Definition at line 3188 of file allpaths.c.
3189{
3193 double rows;
3195
3196 /* If there are no partial paths, there's nothing to do here. */
3198 return;
3199
3200 /* Should we override the rel's rowcount estimate? */
3202 rowsp = &rows;
3203
3204 /*
3205 * The output of Gather is always unsorted, so there's only one partial
3206 * path of interest: the cheapest one. That will be the one at the front
3207 * of partial_pathlist because of the way add_partial_path works.
3208 */
3215
3216 /*
3217 * For each useful ordering, we can consider an order-preserving Gather
3218 * Merge.
3219 */
3221 {
3223 GatherMergePath *path;
3224
3226 continue;
3227
3232 }
3233}
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
Definition pathnode.c:1757
GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
Definition pathnode.c:1809
Definition pathnodes.h:2352
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_gather_path(), fb(), lfirst, linitial, NIL, RelOptInfo::partial_pathlist, GatherMergePath::path, RelOptInfo::reltarget, root, and subpath().
Referenced by generate_useful_gather_paths().
◆ generate_grouped_paths()
| void generate_grouped_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | grouped_rel, | ||
| RelOptInfo * | rel | ||
| ) |
Definition at line 3442 of file allpaths.c.
3444{
3454
3456 {
3457 mark_dummy_rel(grouped_rel);
3458 return;
3459 }
3460
3461 /*
3462 * We push partial aggregation only to the lowest possible level in the
3463 * join tree that is deemed useful.
3464 */
3466 !agg_info->agg_useful)
3467 return;
3468
3471
3472 /*
3473 * Determine whether it's possible to perform sort-based implementations
3474 * of grouping, and generate the pathkeys that represent the grouping
3475 * requirements in that case.
3476 */
3479 {
3482
3484 rel->top_parent->grouped_rel : grouped_rel;
3485 top_group_tlist =
3487
3488 group_pathkeys =
3490 top_group_tlist);
3491 }
3492
3493 /*
3494 * Determine whether we should consider hash-based implementations of
3495 * grouping.
3496 */
3500
3501 /*
3502 * Consider whether we should generate partially aggregated non-partial
3503 * paths. We can only do this if we have a non-partial path.
3504 */
3506 {
3507 cheapest_total_path = rel->cheapest_total_path;
3509 }
3510
3511 /*
3512 * If parallelism is possible for grouped_rel, then we should consider
3513 * generating partially-grouped partial paths. However, if the ungrouped
3514 * rel has no partial paths, then we can't.
3515 */
3517 {
3520 }
3521
3522 /* Estimate number of partial groups. */
3525 agg_info->group_exprs,
3526 cheapest_total_path->rows,
3530 agg_info->group_exprs,
3531 cheapest_partial_path->rows,
3533
3535 {
3537
3538 /*
3539 * Use any available suitably-sorted path as input, and also consider
3540 * sorting the cheapest-total path and incremental sort on any paths
3541 * with presorted keys.
3542 *
3543 * To save planning time, we ignore parameterized input paths unless
3544 * they are the cheapest-total path.
3545 */
3547 {
3549 Path *path;
3551 int presorted_keys;
3552
3553 /*
3554 * Ignore parameterized paths that are not the cheapest-total
3555 * path.
3556 */
3558 input_path != cheapest_total_path)
3559 continue;
3560
3562 input_path->pathkeys,
3563 &presorted_keys);
3564
3565 /*
3566 * Ignore paths that are not suitably or partially sorted, unless
3567 * they are the cheapest total path (no need to deal with paths
3568 * which have presorted keys when incremental sort is disabled).
3569 */
3571 (presorted_keys == 0 || !enable_incremental_sort))
3572 continue;
3573
3574 /*
3575 * Since the path originates from a non-grouped relation that is
3576 * not aware of eager aggregation, we must ensure that it provides
3577 * the correct input for partial aggregation.
3578 */
3580 grouped_rel,
3581 input_path,
3582 agg_info->agg_input);
3583
3585 {
3586 /*
3587 * We've no need to consider both a sort and incremental sort.
3588 * We'll just do a sort if there are no presorted keys and an
3589 * incremental sort when there are presorted keys.
3590 */
3593 grouped_rel,
3594 path,
3595 group_pathkeys,
3596 -1.0);
3597 else
3599 grouped_rel,
3600 path,
3601 group_pathkeys,
3602 presorted_keys,
3603 -1.0);
3604 }
3605
3606 /*
3607 * qual is NIL because the HAVING clause cannot be evaluated until
3608 * the final value of the aggregate is known.
3609 */
3611 grouped_rel,
3612 path,
3613 agg_info->target,
3614 AGG_SORTED,
3615 AGGSPLIT_INITIAL_SERIAL,
3616 agg_info->group_clauses,
3617 NIL,
3618 &agg_costs,
3619 dNumGroups);
3620
3621 add_path(grouped_rel, path);
3622 }
3623 }
3624
3626 {
3628
3629 /* Similar to above logic, but for partial paths. */
3631 {
3633 Path *path;
3635 int presorted_keys;
3636
3638 input_path->pathkeys,
3639 &presorted_keys);
3640
3641 /*
3642 * Ignore paths that are not suitably or partially sorted, unless
3643 * they are the cheapest partial path (no need to deal with paths
3644 * which have presorted keys when incremental sort is disabled).
3645 */
3647 (presorted_keys == 0 || !enable_incremental_sort))
3648 continue;
3649
3650 /*
3651 * Since the path originates from a non-grouped relation that is
3652 * not aware of eager aggregation, we must ensure that it provides
3653 * the correct input for partial aggregation.
3654 */
3656 grouped_rel,
3657 input_path,
3658 agg_info->agg_input);
3659
3661 {
3662 /*
3663 * We've no need to consider both a sort and incremental sort.
3664 * We'll just do a sort if there are no presorted keys and an
3665 * incremental sort when there are presorted keys.
3666 */
3669 grouped_rel,
3670 path,
3671 group_pathkeys,
3672 -1.0);
3673 else
3675 grouped_rel,
3676 path,
3677 group_pathkeys,
3678 presorted_keys,
3679 -1.0);
3680 }
3681
3682 /*
3683 * qual is NIL because the HAVING clause cannot be evaluated until
3684 * the final value of the aggregate is known.
3685 */
3687 grouped_rel,
3688 path,
3689 agg_info->target,
3690 AGG_SORTED,
3691 AGGSPLIT_INITIAL_SERIAL,
3692 agg_info->group_clauses,
3693 NIL,
3694 &agg_costs,
3695 dNumPartialGroups);
3696
3697 add_partial_path(grouped_rel, path);
3698 }
3699 }
3700
3701 /*
3702 * Add a partially-grouped HashAgg Path where possible
3703 */
3705 {
3706 Path *path;
3707
3708 /*
3709 * Since the path originates from a non-grouped relation that is not
3710 * aware of eager aggregation, we must ensure that it provides the
3711 * correct input for partial aggregation.
3712 */
3714 grouped_rel,
3715 cheapest_total_path,
3716 agg_info->agg_input);
3717
3718 /*
3719 * qual is NIL because the HAVING clause cannot be evaluated until the
3720 * final value of the aggregate is known.
3721 */
3723 grouped_rel,
3724 path,
3725 agg_info->target,
3726 AGG_HASHED,
3727 AGGSPLIT_INITIAL_SERIAL,
3728 agg_info->group_clauses,
3729 NIL,
3730 &agg_costs,
3731 dNumGroups);
3732
3733 add_path(grouped_rel, path);
3734 }
3735
3736 /*
3737 * Now add a partially-grouped HashAgg partial Path where possible
3738 */
3740 {
3741 Path *path;
3742
3743 /*
3744 * Since the path originates from a non-grouped relation that is not
3745 * aware of eager aggregation, we must ensure that it provides the
3746 * correct input for partial aggregation.
3747 */
3749 grouped_rel,
3750 cheapest_partial_path,
3751 agg_info->agg_input);
3752
3753 /*
3754 * qual is NIL because the HAVING clause cannot be evaluated until the
3755 * final value of the aggregate is known.
3756 */
3758 grouped_rel,
3759 path,
3760 agg_info->target,
3761 AGG_HASHED,
3762 AGGSPLIT_INITIAL_SERIAL,
3763 agg_info->group_clauses,
3764 NIL,
3765 &agg_costs,
3766 dNumPartialGroups);
3767
3768 add_partial_path(grouped_rel, path);
3769 }
3770}
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
Definition pathkeys.c:558
List * make_pathkeys_for_sortclauses(PlannerInfo *root, List *sortclauses, List *tlist)
Definition pathkeys.c:1336
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
Definition pathnode.c:2531
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
Definition pathnode.c:2799
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
Definition pathnode.c:2848
AggPath * create_agg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, AggStrategy aggstrategy, AggSplit aggsplit, List *groupClause, List *qual, const AggClauseCosts *aggcosts, double numGroups)
Definition pathnode.c:3001
void get_agg_clause_costs(PlannerInfo *root, AggSplit aggsplit, AggClauseCosts *costs)
Definition prepagg.c:559
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
Definition selfuncs.c:3771
Definition pathnodes.h:132
Definition pathnodes.h:1267
List * make_tlist_from_pathtarget(PathTarget *target)
Definition tlist.c:633
References add_partial_path(), add_path(), AGG_HASHED, RelOptInfo::agg_info, RelAggInfo::agg_input, AGG_SORTED, RelAggInfo::agg_useful, AGGSPLIT_INITIAL_SERIAL, RelAggInfo::apply_agg_at, Assert, bms_equal(), RelOptInfo::cheapest_total_path, RelOptInfo::consider_parallel, create_agg_path(), create_incremental_sort_path(), create_projection_path(), create_sort_path(), enable_incremental_sort, estimate_num_groups(), fb(), get_agg_clause_costs(), RelAggInfo::group_clauses, RelAggInfo::group_exprs, RelOptInfo::grouped_rel, grouping_is_hashable(), grouping_is_sortable(), IS_DUMMY_REL, IS_OTHER_REL, lfirst, linitial, make_pathkeys_for_sortclauses(), make_tlist_from_pathtarget(), mark_dummy_rel(), MemSet, NIL, RelOptInfo::partial_pathlist, pathkeys_count_contained_in(), RelOptInfo::pathlist, RelOptInfo::relids, root, Path::rows, and RelAggInfo::target.
Referenced by generate_partitionwise_join_paths(), merge_clump(), set_grouped_rel_pathlist(), and standard_join_search().
◆ generate_orderedappend_paths()
|
static |
Definition at line 1832 of file allpaths.c.
1835{
1841
1842 /*
1843 * Some partitioned table setups may allow us to use an Append node
1844 * instead of a MergeAppend. This is possible in cases such as RANGE
1845 * partitioned tables where it's guaranteed that an earlier partition must
1846 * contain rows which come earlier in the sort order. To detect whether
1847 * this is relevant, build pathkey descriptions of the partition ordering,
1848 * for both forward and reverse scans.
1849 */
1852 {
1854 ForwardScanDirection,
1855 &partition_pathkeys_partial);
1856
1858 BackwardScanDirection,
1859 &partition_pathkeys_desc_partial);
1860
1861 /*
1862 * You might think we should truncate_useless_pathkeys here, but
1863 * allowing partition keys which are a subset of the query's pathkeys
1864 * can often be useful. For example, consider a table partitioned by
1865 * RANGE (a, b), and a query with ORDER BY a, b, c. If we have child
1866 * paths that can produce the a, b, c ordering (perhaps via indexes on
1867 * (a, b, c)) then it works to consider the appendrel output as
1868 * ordered by a, b, c.
1869 */
1870 }
1871
1872 /* Now consider each interesting sort ordering */
1874 {
1885 int direction;
1886
1887 /*
1888 * Determine if this sort ordering matches any partition pathkeys we
1889 * have, for both ascending and descending partition order. If the
1890 * partition pathkeys happen to be contained in pathkeys then it still
1891 * works, as described above, providing that the partition pathkeys
1892 * are complete and not just a prefix of the partition keys. (In such
1893 * cases we'll be relying on the child paths to have sorted the
1894 * lower-order columns of the required pathkeys.)
1895 */
1896 match_partition_order =
1898 (!partition_pathkeys_partial &&
1900
1903 (!partition_pathkeys_desc_partial &&
1905
1906 /*
1907 * When the required pathkeys match the reverse of the partition
1908 * order, we must build the list of paths in reverse starting with the
1909 * last matching partition first. We can get away without making any
1910 * special cases for this in the loop below by just looping backward
1911 * over the child relations in this case.
1912 */
1914 {
1915 /* loop backward */
1917 end_index = -1;
1918 direction = -1;
1919
1920 /*
1921 * Set this to true to save us having to check for
1922 * match_partition_order_desc in the loop below.
1923 */
1925 }
1926 else
1927 {
1928 /* for all other case, loop forward */
1929 first_index = 0;
1931 direction = 1;
1932 }
1933
1934 /* Select the child paths for this ordering... */
1936 {
1939 *cheapest_total,
1941
1942 /* Locate the right paths, if they are available. */
1943 cheapest_startup =
1945 pathkeys,
1946 NULL,
1947 STARTUP_COST,
1948 false);
1949 cheapest_total =
1951 pathkeys,
1952 NULL,
1953 TOTAL_COST,
1954 false);
1955
1956 /*
1957 * If we can't find any paths with the right order just use the
1958 * cheapest-total path; we'll have to sort it later.
1959 */
1961 {
1963 childrel->cheapest_total_path;
1964 /* Assert we do have an unparameterized path for this child */
1966 }
1967
1968 /*
1969 * When building a fractional path, determine a cheapest
1970 * fractional path for each child relation too. Looking at startup
1971 * and total costs is not enough, because the cheapest fractional
1972 * path may be dominated by two separate paths (one for startup,
1973 * one for total).
1974 *
1975 * When needed (building fractional path), determine the cheapest
1976 * fractional path too.
1977 */
1979 {
1981
1982 /*
1983 * We should not have a dummy child relation here. However,
1984 * we cannot use childrel->rows to compute the tuple fraction,
1985 * as childrel can be an upper relation with an unset row
1986 * estimate. Instead, we use the row estimate from the
1987 * cheapest_total path, which should already have been forced
1988 * to a sane value.
1989 */
1991
1992 /* Convert absolute limit to a path fraction */
1995
1996 cheapest_fractional =
1998 pathkeys,
1999 NULL,
2000 path_fraction);
2001
2002 /*
2003 * If we found no path with matching pathkeys, use the
2004 * cheapest total path instead.
2005 *
2006 * XXX We might consider partially sorted paths too (with an
2007 * incremental sort on top). But we'd have to build all the
2008 * incremental paths, do the costing etc.
2009 *
2010 * Also, notice whether we actually have different paths for
2011 * the "fractional" and "total" cases. This helps avoid
2012 * generating two identical ordered append paths.
2013 */
2018 }
2019
2020 /*
2021 * Notice whether we actually have different paths for the
2022 * "cheapest" and "total" cases. This helps avoid generating two
2023 * identical ordered append paths.
2024 */
2027
2028 /*
2029 * Collect the appropriate child paths. The required logic varies
2030 * for the Append and MergeAppend cases.
2031 */
2033 {
2034 /*
2035 * We're going to make a plain Append path. We don't need
2036 * most of what accumulate_append_subpath would do, but we do
2037 * want to cut out child Appends or MergeAppends if they have
2038 * just a single subpath (and hence aren't doing anything
2039 * useful).
2040 */
2043
2046
2048 {
2051 }
2052 }
2053 else
2054 {
2055 /*
2056 * Otherwise, rely on accumulate_append_subpath to collect the
2057 * child paths for the MergeAppend.
2058 */
2063
2067 }
2068 }
2069
2070 /* ... and build the Append or MergeAppend paths */
2072 {
2073 /* We only need Append */
2075 rel,
2076 startup_subpaths,
2077 NIL,
2078 pathkeys,
2079 NULL,
2080 0,
2081 false,
2082 -1));
2085 rel,
2086 total_subpaths,
2087 NIL,
2088 pathkeys,
2089 NULL,
2090 0,
2091 false,
2092 -1));
2093
2096 rel,
2097 fractional_subpaths,
2098 NIL,
2099 pathkeys,
2100 NULL,
2101 0,
2102 false,
2103 -1));
2104 }
2105 else
2106 {
2107 /* We need MergeAppend */
2109 rel,
2110 startup_subpaths,
2111 pathkeys,
2112 NULL));
2115 rel,
2116 total_subpaths,
2117 pathkeys,
2118 NULL));
2119
2122 rel,
2123 fractional_subpaths,
2124 pathkeys,
2125 NULL));
2126 }
2127 }
2128}
static Path * get_singleton_append_subpath(Path *path)
Definition allpaths.c:2271
bool partitions_are_ordered(PartitionBoundInfo boundinfo, Bitmapset *live_parts)
Definition partbounds.c:2845
Path * get_cheapest_fractional_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, double fraction)
Definition pathkeys.c:666
Path * get_cheapest_path_for_pathkeys(List *paths, List *pathkeys, Relids required_outer, CostSelector cost_criterion, bool require_parallel_safe)
Definition pathkeys.c:620
List * build_partition_pathkeys(PlannerInfo *root, RelOptInfo *partrel, ScanDirection scandir, bool *partialkeys)
Definition pathkeys.c:919
MergeAppendPath * create_merge_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *pathkeys, Relids required_outer)
Definition pathnode.c:1470
References accumulate_append_subpath(), add_path(), Assert, BackwardScanDirection, build_partition_pathkeys(), create_append_path(), create_merge_append_path(), fb(), ForwardScanDirection, get_cheapest_fractional_path_for_pathkeys(), get_cheapest_path_for_pathkeys(), get_singleton_append_subpath(), i, IS_SIMPLE_REL, lappend(), lfirst, list_length(), list_nth_node, RelOptInfo::live_parts, NIL, partitions_are_ordered(), pathkeys_contained_in(), root, STARTUP_COST, and TOTAL_COST.
Referenced by add_paths_to_append_rel().
◆ generate_partitionwise_join_paths()
| void generate_partitionwise_join_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | rel | ||
| ) |
Definition at line 4814 of file allpaths.c.
4815{
4820
4821 /* Handle only join relations here. */
4823 return;
4824
4825 /* We've nothing to do if the relation is not partitioned. */
4827 return;
4828
4829 /* The relation should have consider_partitionwise_join set. */
4831
4832 /* Guard against stack overflow due to overly deep partition hierarchy. */
4833 check_stack_depth();
4834
4836 part_rels = rel->part_rels;
4837
4838 /* Collect non-dummy child-joins. */
4840 {
4842
4843 /* If it's been pruned entirely, it's certainly dummy. */
4845 continue;
4846
4847 /* Make partitionwise join paths for this partitioned child-join. */
4849
4850 /* If we failed to make any path for this child, we must give up. */
4852 {
4853 /*
4854 * Mark the parent joinrel as unpartitioned so that later
4855 * functions treat it correctly.
4856 */
4857 rel->nparts = 0;
4858 return;
4859 }
4860
4861 /* Else, identify the cheapest path for it. */
4863
4864 /* Dummy children need not be scanned, so ignore those. */
4866 continue;
4867
4868 /*
4869 * Except for the topmost scan/join rel, consider generating partial
4870 * aggregation paths for the grouped relation on top of the paths of
4871 * this partitioned child-join. After that, we're done creating paths
4872 * for the grouped relation, so run set_cheapest().
4873 */
4876 rel->top_parent_relids : rel->relids,
4877 root->all_query_rels))
4878 {
4880
4882
4884 set_cheapest(grouped_rel);
4885 }
4886
4887#ifdef OPTIMIZER_DEBUG
4889#endif
4890
4892 }
4893
4894 /* If all child-joins are dummy, parent join is also dummy. */
4896 {
4897 mark_dummy_rel(rel);
4898 return;
4899 }
4900
4901 /* Build additional paths for this rel from child-join paths. */
4904}
void generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
Definition allpaths.c:4814
void generate_grouped_paths(PlannerInfo *root, RelOptInfo *grouped_rel, RelOptInfo *rel)
Definition allpaths.c:3442
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
Definition allpaths.c:1404
References add_paths_to_append_rel(), Assert, bms_equal(), check_stack_depth(), RelOptInfo::consider_partitionwise_join, fb(), generate_grouped_paths(), generate_partitionwise_join_paths(), RelOptInfo::grouped_rel, IS_DUMMY_REL, IS_GROUPED_REL, IS_JOIN_REL, IS_OTHER_REL, IS_PARTITIONED_REL, lappend(), list_free(), mark_dummy_rel(), NIL, RelOptInfo::nparts, pprint(), RelOptInfo::relids, root, set_cheapest(), and RelOptInfo::top_parent_relids.
Referenced by generate_partitionwise_join_paths(), merge_clump(), and standard_join_search().
◆ generate_useful_gather_paths()
| void generate_useful_gather_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | rel, | ||
| bool | override_rows | ||
| ) |
Definition at line 3325 of file allpaths.c.
3326{
3328 double rows;
3332
3333 /* If there are no partial paths, there's nothing to do here. */
3335 return;
3336
3337 /* Should we override the rel's rowcount estimate? */
3339 rowsp = &rows;
3340
3341 /* generate the regular gather (merge) paths */
3343
3344 /* consider incremental sort for interesting orderings */
3346
3347 /* used for explicit (full) sort paths */
3349
3350 /*
3351 * Consider sorted paths for each interesting ordering. We generate both
3352 * incremental and full sort.
3353 */
3355 {
3359 int presorted_keys;
3360
3362 {
3364 GatherMergePath *path;
3365
3367 subpath->pathkeys,
3368 &presorted_keys);
3369
3370 /*
3371 * We don't need to consider the case where a subpath is already
3372 * fully sorted because generate_gather_paths already creates a
3373 * gather merge path for every subpath that has pathkeys present.
3374 *
3375 * But since the subpath is already sorted, we know we don't need
3376 * to consider adding a sort (full or incremental) on top of it,
3377 * so we can continue here.
3378 */
3380 continue;
3381
3382 /*
3383 * Try at least sorting the cheapest path and also try
3384 * incrementally sorting any path which is partially sorted
3385 * already (no need to deal with paths which have presorted keys
3386 * when incremental sort is disabled unless it's the cheapest
3387 * input path).
3388 */
3390 (presorted_keys == 0 || !enable_incremental_sort))
3391 continue;
3392
3393 /*
3394 * Consider regular sort for any path that's not presorted or if
3395 * incremental sort is disabled. We've no need to consider both
3396 * sort and incremental sort on the same path. We assume that
3397 * incremental sort is always faster when there are presorted
3398 * keys.
3399 *
3400 * This is not redundant with the gather paths created in
3401 * generate_gather_paths, because that doesn't generate ordered
3402 * output. Here we add an explicit sort to match the useful
3403 * ordering.
3404 */
3406 {
3408 rel,
3409 subpath,
3410 useful_pathkeys,
3411 -1.0);
3412 }
3413 else
3415 rel,
3416 subpath,
3417 useful_pathkeys,
3418 presorted_keys,
3419 -1);
3422 subpath,
3423 rel->reltarget,
3424 subpath->pathkeys,
3425 NULL,
3426 rowsp);
3427
3429 }
3430 }
3431}
static List * get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel, bool require_parallel_safe)
Definition allpaths.c:3257
void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition allpaths.c:3188
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, fb(), generate_gather_paths(), get_useful_pathkeys_for_relation(), lfirst, linitial, NIL, RelOptInfo::partial_pathlist, GatherMergePath::path, pathkeys_count_contained_in(), RelOptInfo::reltarget, root, and subpath().
Referenced by apply_scanjoin_target_to_paths(), create_partial_distinct_paths(), create_partial_unique_paths(), gather_grouping_paths(), merge_clump(), set_rel_pathlist(), and standard_join_search().
◆ get_cheapest_parameterized_child_path()
|
static |
Definition at line 2138 of file allpaths.c.
2140{
2143
2144 /*
2145 * Look up the cheapest existing path with no more than the needed
2146 * parameterization. If it has exactly the needed parameterization, we're
2147 * done.
2148 */
2150 NIL,
2151 required_outer,
2152 TOTAL_COST,
2153 false);
2157
2158 /*
2159 * Otherwise, we can "reparameterize" an existing path to match the given
2160 * parameterization, which effectively means pushing down additional
2161 * joinquals to be checked within the path's scan. However, some existing
2162 * paths might check the available joinquals already while others don't;
2163 * therefore, it's not clear which existing path will be cheapest after
2164 * reparameterization. We have to go through them all and find out.
2165 */
2168 {
2170
2171 /* Can't use it if it needs more than requested parameterization */
2173 continue;
2174
2175 /*
2176 * Reparameterization can only increase the path's cost, so if it's
2177 * already more expensive than the current cheapest, forget it.
2178 */
2181 continue;
2182
2183 /* Reparameterize if needed, then recheck cost */
2185 {
2188 continue; /* failed to reparameterize this one */
2190
2193 continue;
2194 }
2195
2196 /* We have a new best path */
2197 cheapest = path;
2198 }
2199
2200 /* Return the best path, or NULL if we found no suitable candidate */
2202}
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
Definition pathnode.c:68
Path * reparameterize_path(PlannerInfo *root, Path *path, Relids required_outer, double loop_count)
Definition pathnode.c:3860
References Assert, bms_equal(), bms_is_subset(), compare_path_costs(), fb(), get_cheapest_path_for_pathkeys(), lfirst, NIL, PATH_REQ_OUTER, RelOptInfo::pathlist, reparameterize_path(), root, and TOTAL_COST.
Referenced by add_paths_to_append_rel().
◆ get_singleton_append_subpath()
Definition at line 2271 of file allpaths.c.
2272{
2274
2276 {
2278
2281 }
2283 {
2285
2288 }
2289
2290 return path;
2291}
References Assert, fb(), IsA, linitial, list_length(), and Path::parallel_aware.
Referenced by generate_orderedappend_paths().
◆ get_useful_pathkeys_for_relation()
|
static |
Definition at line 3257 of file allpaths.c.
3259{
3261
3262 /*
3263 * Considering query_pathkeys is always worth it, because it might allow
3264 * us to avoid a total sort when we have a partially presorted path
3265 * available or to push the total sort into the parallel portion of the
3266 * query.
3267 */
3269 {
3272
3274 {
3277
3278 /*
3279 * We can only build a sort for pathkeys that contain a
3280 * safe-to-compute-early EC member computable from the current
3281 * relation's reltarget, so ignore the remainder of the list as
3282 * soon as we find a pathkey without such a member.
3283 *
3284 * It's still worthwhile to return any prefix of the pathkeys list
3285 * that meets this requirement, as we may be able to do an
3286 * incremental sort.
3287 *
3288 * If requested, ensure the sort expression is parallel-safe too.
3289 */
3291 require_parallel_safe))
3292 break;
3293
3294 npathkeys++;
3295 }
3296
3297 /*
3298 * The whole query_pathkeys list matches, so append it directly, to
3299 * allow comparing pathkeys easily by comparing list pointer. If we
3300 * have to truncate the pathkeys, we gotta do a copy though.
3301 */
3304 root->query_pathkeys);
3308 npathkeys));
3309 }
3310
3312}
bool relation_can_be_sorted_early(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, bool require_parallel_safe)
Definition equivclass.c:1076
Definition pathnodes.h:1634
Definition pathnodes.h:1787
References fb(), lappend(), lfirst, list_copy_head(), list_length(), NIL, relation_can_be_sorted_early(), and root.
Referenced by generate_useful_gather_paths().
◆ make_one_rel()
| RelOptInfo * make_one_rel | ( | PlannerInfo * | root, |
| List * | joinlist | ||
| ) |
Definition at line 177 of file allpaths.c.
178{
179 RelOptInfo *rel;
180 Index rti;
182
183 /* Mark base rels as to whether we care about fast-start plans */
185
186 /*
187 * Compute size estimates and consider_parallel flags for each base rel.
188 */
190
191 /*
192 * Build grouped relations for simple rels (i.e., base or "other" member
193 * relations) where possible.
194 */
196
197 /*
198 * We should now have size estimates for every actual table involved in
199 * the query, and we also know which if any have been deleted from the
200 * query by join removal, pruned by partition pruning, or eliminated by
201 * constraint exclusion. So we can now compute total_table_pages.
202 *
203 * Note that appendrels are not double-counted here, even though we don't
204 * bother to distinguish RelOptInfos for appendrel parents, because the
205 * parents will have pages = 0.
206 *
207 * XXX if a table is self-joined, we will count it once per appearance,
208 * which perhaps is the wrong thing ... but that's not completely clear,
209 * and detecting self-joins here is difficult, so ignore it for now.
210 */
211 total_pages = 0;
213 {
215
216 /* there may be empty slots corresponding to non-baserel RTEs */
218 continue;
219
221
223 continue;
224
227 }
229
230 /*
231 * Generate access paths for each base rel.
232 */
234
235 /*
236 * Generate access paths for the entire join tree.
237 */
239
240 /*
241 * The result should join all and only the query's base + outer-join rels.
242 */
244
245 return rel;
246}
static void set_base_rel_consider_startup(PlannerInfo *root)
Definition allpaths.c:259
static void set_base_rel_pathlists(PlannerInfo *root)
Definition allpaths.c:378
static RelOptInfo * make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
Definition allpaths.c:3780
static void setup_simple_grouped_rels(PlannerInfo *root)
Definition allpaths.c:344
References Assert, bms_equal(), fb(), IS_DUMMY_REL, IS_SIMPLE_REL, make_rel_from_joinlist(), RelOptInfo::relids, root, set_base_rel_consider_startup(), set_base_rel_pathlists(), set_base_rel_sizes(), and setup_simple_grouped_rels().
Referenced by query_planner().
◆ make_rel_from_joinlist()
|
static |
Definition at line 3780 of file allpaths.c.
3781{
3783 List *initial_rels;
3785
3786 /*
3787 * Count the number of child joinlist nodes. This is the depth of the
3788 * dynamic-programming algorithm we must employ to consider all ways of
3789 * joining the child nodes.
3790 */
3792
3795
3796 /*
3797 * Construct a list of rels corresponding to the child joinlist nodes.
3798 * This may contain both base rels and rels constructed according to
3799 * sub-joinlists.
3800 */
3801 initial_rels = NIL;
3803 {
3806
3808 {
3810
3812 }
3814 {
3815 /* Recurse to handle subproblem */
3817 }
3818 else
3819 {
3823 }
3824
3826 }
3827
3829 {
3830 /*
3831 * Single joinlist node, so we're done.
3832 */
3834 }
3835 else
3836 {
3837 /*
3838 * Consider the different orders in which we could join the rels,
3839 * using a plugin, GEQO, or the regular join search code.
3840 *
3841 * We put the initial_rels list into a PlannerInfo field because
3842 * has_legal_joinclause() needs to look at it (ugly :-().
3843 */
3844 root->initial_rels = initial_rels;
3845
3850 else
3852 }
3853}
RelOptInfo * standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
Definition allpaths.c:3885
RelOptInfo * geqo(PlannerInfo *root, int number_of_rels, List *initial_rels)
Definition geqo_main.c:74
Definition primnodes.h:2293
References elog, enable_geqo, ERROR, fb(), find_base_rel(), geqo(), geqo_threshold, IsA, join_search_hook, lappend(), lfirst, linitial, list_length(), make_rel_from_joinlist(), NIL, nodeTag, root, and standard_join_search().
Referenced by make_one_rel(), and make_rel_from_joinlist().
◆ qual_is_pushdown_safe()
|
static |
Definition at line 4377 of file allpaths.c.
4379{
4384
4385 /* Refuse subselects (point 1) */
4388
4389 /* Refuse volatile quals if we found they'd be unsafe (point 2) */
4393
4394 /* Refuse leaky quals if told to (point 3) */
4396 contain_leaked_vars(qual))
4398
4399 /*
4400 * Examine all Vars used in clause. Since it's a restriction clause, all
4401 * such Vars must refer to subselect output columns ... unless this is
4402 * part of a LATERAL subquery, in which case there could be lateral
4403 * references.
4404 *
4405 * By omitting the relevant flags, this also gives us a cheap sanity check
4406 * that no aggregates or window functions appear in the qual. Those would
4407 * be unsafe to push down, but at least for the moment we could never see
4408 * any in a qual anyhow.
4409 */
4412 {
4414
4415 /*
4416 * XXX Punt if we find any PlaceHolderVars in the restriction clause.
4417 * It's not clear whether a PHV could safely be pushed down, and even
4418 * less clear whether such a situation could arise in any cases of
4419 * practical interest anyway. So for the moment, just refuse to push
4420 * down.
4421 */
4423 {
4425 break;
4426 }
4427
4428 /*
4429 * Punt if we find any lateral references. It would be safe to push
4430 * these down, but we'd have to convert them into outer references,
4431 * which subquery_push_qual lacks the infrastructure to do. The case
4432 * arises so seldom that it doesn't seem worth working hard on.
4433 */
4435 {
4437 break;
4438 }
4439
4440 /* Subqueries have no system columns */
4442
4443 /* Check point 4 */
4445 {
4447 break;
4448 }
4449
4450 /* Check point 5 */
4452 {
4456 {
4458 break;
4459 }
4460 else
4461 {
4462 /* UNSAFE_NOTIN_PARTITIONBY_CLAUSE is ok for run conditions */
4464 /* don't break, we might find another Var that's unsafe */
4465 }
4466 }
4467 }
4468
4470
4472}
Definition regcomp.c:282
References Assert, RestrictInfo::clause, contain_leaked_vars(), contain_subplans(), contain_volatile_functions(), fb(), IsA, lfirst, list_free(), pull_var_clause(), PUSHDOWN_SAFE, PUSHDOWN_UNSAFE, PUSHDOWN_WINDOWCLAUSE_RUNCOND, PVC_INCLUDE_PLACEHOLDERS, UNSAFE_HAS_SET_FUNC, UNSAFE_HAS_VOLATILE_FUNC, UNSAFE_NOTIN_DISTINCTON_CLAUSE, UNSAFE_TYPE_MISMATCH, Var::varattno, and Var::varno.
Referenced by set_subquery_pathlist().
◆ recurse_push_qual()
|
static |
Definition at line 4526 of file allpaths.c.
4528{
4530 {
4534
4537 }
4539 {
4541
4544 }
4545 else
4546 {
4549 }
4550}
static void subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
Definition allpaths.c:4478
static void recurse_push_qual(Node *setOp, Query *topquery, RangeTblEntry *rte, Index rti, Node *qual)
Definition allpaths.c:4526
Definition parsenodes.h:118
Definition parsenodes.h:1085
Definition parsenodes.h:2280
References Assert, elog, ERROR, fb(), IsA, SetOperationStmt::larg, nodeTag, SetOperationStmt::rarg, recurse_push_qual(), rt_fetch, and subquery_push_qual().
Referenced by recurse_push_qual(), and subquery_push_qual().
◆ recurse_pushdown_safe()
|
static |
Definition at line 4136 of file allpaths.c.
4138{
4140 {
4144
4147 }
4149 {
4151
4152 /* EXCEPT is no good (point 2 for subquery_is_pushdown_safe) */
4154 return false;
4155 /* Else recurse */
4157 return false;
4159 return false;
4160 }
4161 else
4162 {
4165 }
4166 return true;
4167}
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery, pushdown_safety_info *safetyInfo)
Definition allpaths.c:4080
static bool recurse_pushdown_safe(Node *setOp, Query *topquery, pushdown_safety_info *safetyInfo)
Definition allpaths.c:4136
References Assert, elog, ERROR, fb(), IsA, SetOperationStmt::larg, nodeTag, SetOperationStmt::op, SetOperationStmt::rarg, recurse_pushdown_safe(), rt_fetch, SETOP_EXCEPT, and subquery_is_pushdown_safe().
Referenced by recurse_pushdown_safe(), and subquery_is_pushdown_safe().
◆ remove_unused_subquery_outputs()
|
static |
Definition at line 4578 of file allpaths.c.
4580{
4581 Bitmapset *attrs_used;
4583
4584 /*
4585 * Just point directly to extra_used_attrs. No need to bms_copy as none of
4586 * the current callers use the Bitmapset after calling this function.
4587 */
4588 attrs_used = extra_used_attrs;
4589
4590 /*
4591 * Do nothing if subquery has UNION/INTERSECT/EXCEPT: in principle we
4592 * could update all the child SELECTs' tlists, but it seems not worth the
4593 * trouble presently.
4594 */
4596 return;
4597
4598 /*
4599 * If subquery has regular DISTINCT (not DISTINCT ON), we're wasting our
4600 * time: all its output columns must be used in the distinctClause.
4601 */
4603 return;
4604
4605 /*
4606 * Collect a bitmap of all the output column numbers used by the upper
4607 * query.
4608 *
4609 * Add all the attributes needed for joins or final output. Note: we must
4610 * look at rel's targetlist, not the attr_needed data, because attr_needed
4611 * isn't computed for inheritance child rels, cf set_append_rel_size().
4612 * (XXX might be worth changing that sometime.)
4613 */
4615
4616 /* Add all the attributes used by un-pushed-down restriction clauses. */
4618 {
4620
4622 }
4623
4624 /*
4625 * If there's a whole-row reference to the subquery, we can't remove
4626 * anything.
4627 */
4629 return;
4630
4631 /*
4632 * Run through the tlist and zap entries we don't need. It's okay to
4633 * modify the tlist items in-place because set_subquery_pathlist made a
4634 * copy of the subquery.
4635 */
4637 {
4640
4641 /*
4642 * If it has a sortgroupref number, it's used in some sort/group
4643 * clause so we'd better not remove it. Also, don't remove any
4644 * resjunk columns, since their reason for being has nothing to do
4645 * with anybody reading the subquery's output. (It's likely that
4646 * resjunk columns in a sub-SELECT would always have ressortgroupref
4647 * set, but even if they don't, it seems imprudent to remove them.)
4648 */
4650 continue;
4651
4652 /*
4653 * If it's used by the upper query, we can't remove it.
4654 */
4656 attrs_used))
4657 continue;
4658
4659 /*
4660 * If it contains a set-returning function, we can't remove it since
4661 * that could change the number of rows returned by the subquery.
4662 */
4663 if (subquery->hasTargetSRFs &&
4665 continue;
4666
4667 /*
4668 * If it contains volatile functions, we daren't remove it for fear
4669 * that the user is expecting their side-effects to happen.
4670 */
4672 continue;
4673
4674 /*
4675 * OK, we don't need it. Replace the expression with a NULL constant.
4676 * Preserve the exposed type of the expression, in case something
4677 * looks at the rowtype of the subquery's result.
4678 */
4682 }
4683}
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition makefuncs.c:388
Definition pathnodes.h:2864
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)
Definition var.c:296
References RelOptInfo::baserestrictinfo, bms_is_member(), RestrictInfo::clause, contain_volatile_functions(), Query::distinctClause, exprCollation(), expression_returns_set(), PathTarget::exprs, exprType(), exprTypmod(), fb(), FirstLowInvalidHeapAttributeNumber, lfirst, makeNullConst(), pull_varattnos(), RelOptInfo::relid, RelOptInfo::reltarget, Query::setOperations, and Query::targetList.
Referenced by set_subquery_pathlist().
◆ set_append_rel_pathlist()
|
static |
Definition at line 1305 of file allpaths.c.
1307{
1310 ListCell *l;
1311
1312 /*
1313 * Generate access paths for each member relation, and remember the
1314 * non-dummy children.
1315 */
1317 {
1322
1323 /* append_rel_list contains all append rels; ignore others */
1325 continue;
1326
1327 /* Re-locate the child RTE and RelOptInfo */
1331
1332 /*
1333 * If set_append_rel_size() decided the parent appendrel was
1334 * parallel-unsafe at some point after visiting this child rel, we
1335 * need to propagate the unsafety marking down to the child, so that
1336 * we don't generate useless partial paths for it.
1337 */
1340
1341 /*
1342 * Compute the child's access paths.
1343 */
1345
1346 /*
1347 * If child is dummy, ignore it.
1348 */
1350 continue;
1351
1352 /*
1353 * Child is live, so add it to the live_childrels list for use below.
1354 */
1356 }
1357
1358 /* Add paths to the append relation. */
1360}
static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition allpaths.c:514
Definition pathnodes.h:3259
References add_paths_to_append_rel(), RelOptInfo::consider_parallel, fb(), IS_DUMMY_REL, lappend(), lfirst, NIL, root, and set_rel_pathlist().
Referenced by set_rel_pathlist().
◆ set_append_rel_size()
|
static |
Definition at line 1010 of file allpaths.c.
1012{
1019 int nattrs;
1020 ListCell *l;
1021
1022 /* Guard against stack overflow due to overly deep inheritance tree. */
1023 check_stack_depth();
1024
1026
1027 /*
1028 * If this is a partitioned baserel, set the consider_partitionwise_join
1029 * flag; currently, we only consider partitionwise joins with the baserel
1030 * if its targetlist doesn't contain a whole-row Var.
1031 */
1037
1038 /*
1039 * Initialize to compute size estimates for whole append relation.
1040 *
1041 * We handle tuples estimates by setting "tuples" to the total number of
1042 * tuples accumulated from each live child, rather than using "rows".
1043 * Although an appendrel itself doesn't directly enforce any quals, its
1044 * child relations may. Therefore, setting "tuples" equal to "rows" for
1045 * an appendrel isn't always appropriate, and can lead to inaccurate cost
1046 * estimates. For example, when estimating the number of distinct values
1047 * from an appendrel, we would be unable to adjust the estimate based on
1048 * the restriction selectivity (see estimate_num_groups).
1049 *
1050 * We handle width estimates by weighting the widths of different child
1051 * rels proportionally to their number of rows. This is sensible because
1052 * the use of width estimates is mainly to compute the total relation
1053 * "footprint" if we have to sort or hash it. To do this, we sum the
1054 * total equivalent size (in "double" arithmetic) and then divide by the
1055 * total rowcount estimate. This is done separately for the total rel
1056 * width and each attribute.
1057 *
1058 * Note: if you consider changing this logic, beware that child rels could
1059 * have zero rows and/or width, if they were excluded by constraints.
1060 */
1062 parent_tuples = 0;
1063 parent_rows = 0;
1064 parent_size = 0;
1067
1069 {
1078
1079 /* append_rel_list contains all append rels; ignore others */
1081 continue;
1082
1085
1086 /*
1087 * The child rel's RelOptInfo was already created during
1088 * add_other_rels_to_query.
1089 */
1092
1093 /* We may have already proven the child to be dummy. */
1095 continue;
1096
1097 /*
1098 * We have to copy the parent's targetlist and quals to the child,
1099 * with appropriate substitution of variables. However, the
1100 * baserestrictinfo quals were already copied/substituted when the
1101 * child RelOptInfo was built. So we don't need any additional setup
1102 * before applying constraint exclusion.
1103 */
1105 {
1106 /*
1107 * This child need not be scanned, so we can omit it from the
1108 * appendrel.
1109 */
1111 continue;
1112 }
1113
1114 /*
1115 * Constraint exclusion failed, so copy the parent's join quals and
1116 * targetlist to the child, with appropriate variable substitutions.
1117 *
1118 * We skip join quals that came from above outer joins that can null
1119 * this rel, since they would be of no value while generating paths
1120 * for the child. This saves some effort while processing the child
1121 * rel, and it also avoids an implementation restriction in
1122 * adjust_appendrel_attrs (it can't apply nullingrels to a non-Var).
1123 */
1126 {
1128
1132 (Node *) rinfo,
1133 1, &appinfo));
1134 }
1136
1137 /*
1138 * Now for the child's targetlist.
1139 *
1140 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
1141 * expressions, which otherwise would not occur in a rel's targetlist.
1142 * Code that might be looking at an appendrel child must cope with
1143 * such. (Normally, a rel's targetlist would only include Vars and
1144 * PlaceHolderVars.) XXX we do not bother to update the cost or width
1145 * fields of childrel->reltarget; not clear if that would be useful.
1146 */
1150 1, &appinfo);
1151
1152 /*
1153 * We have to make child entries in the EquivalenceClass data
1154 * structures as well. This is needed either if the parent
1155 * participates in some eclass joins (because we will want to consider
1156 * inner-indexscan joins on the individual children) or if the parent
1157 * has useful pathkeys (because we should try to build MergeAppend
1158 * paths that produce those sort orderings).
1159 */
1163
1164 /*
1165 * Note: we could compute appropriate attr_needed data for the child's
1166 * variables, by transforming the parent's attr_needed through the
1167 * translated_vars mapping. However, currently there's no need
1168 * because attr_needed is only examined for base relations not
1169 * otherrels. So we just leave the child's attr_needed empty.
1170 */
1171
1172 /*
1173 * If we consider partitionwise joins with the parent rel, do the same
1174 * for partitioned child rels.
1175 *
1176 * Note: here we abuse the consider_partitionwise_join flag by setting
1177 * it for child rels that are not themselves partitioned. We do so to
1178 * tell try_partitionwise_join() that the child rel is sufficiently
1179 * valid to be used as a per-partition input, even if it later gets
1180 * proven to be dummy. (It's not usable until we've set up the
1181 * reltarget and EC entries, which we just did.)
1182 */
1185
1186 /*
1187 * If parallelism is allowable for this query in general, see whether
1188 * it's allowable for this childrel in particular. But if we've
1189 * already decided the appendrel is not parallel-safe as a whole,
1190 * there's no point in considering parallelism for this child. For
1191 * consistency, do this before calling set_rel_size() for the child.
1192 */
1195
1196 /*
1197 * Compute the child's size.
1198 */
1200
1201 /*
1202 * It is possible that constraint exclusion detected a contradiction
1203 * within a child subquery, even though we didn't prove one above. If
1204 * so, we can skip this child.
1205 */
1207 continue;
1208
1209 /* We have at least one live child. */
1211
1212 /*
1213 * If any live child is not parallel-safe, treat the whole appendrel
1214 * as not parallel-safe. In future we might be able to generate plans
1215 * in which some children are farmed out to workers while others are
1216 * not; but we don't have that today, so it's a waste to consider
1217 * partial paths anywhere in the appendrel unless it's all safe.
1218 * (Child rels visited before this one will be unmarked in
1219 * set_append_rel_pathlist().)
1220 */
1223
1224 /*
1225 * Accumulate size information from each live child.
1226 */
1228
1232
1233 /*
1234 * Accumulate per-column estimates too. We need not do anything for
1235 * PlaceHolderVars in the parent list. If child expression isn't a
1236 * Var, or we didn't record a width estimate for it, we have to fall
1237 * back on a datatype-based estimate.
1238 *
1239 * By construction, child's targetlist is 1-to-1 with parent's.
1240 */
1243 {
1246
1248 {
1251
1254 {
1256
1258 }
1264 }
1265 }
1266 }
1267
1269 {
1270 /*
1271 * Save the finished size estimates.
1272 */
1274
1281
1282 /*
1283 * Note that we leave rel->pages as zero; this is important to avoid
1284 * double-counting the appendrel tree in total_table_pages.
1285 */
1286 }
1287 else
1288 {
1289 /*
1290 * All children were excluded by constraints, so mark the whole
1291 * appendrel dummy. We must do this in this phase so that the rel's
1292 * dummy-ness is visible when we generate paths for other rels.
1293 */
1294 set_dummy_rel_pathlist(rel);
1295 }
1296
1298}
static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:643
static void set_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition allpaths.c:405
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Definition appendinfo.c:200
void add_child_rel_equivalences(PlannerInfo *root, AppendRelInfo *appinfo, RelOptInfo *parent_rel, RelOptInfo *child_rel)
Definition equivclass.c:2832
bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
Definition pathkeys.c:2291
bool relation_excluded_by_constraints(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition plancat.c:1854
References add_child_rel_equivalences(), adjust_appendrel_attrs(), Assert, bms_is_empty, bms_overlap(), check_stack_depth(), RelOptInfo::consider_parallel, RelOptInfo::consider_partitionwise_join, enable_partitionwise_join, PathTarget::exprs, exprType(), exprTypmod(), fb(), find_base_rel(), forboth, get_typavgwidth(), RelOptInfo::has_eclass_joins, has_useful_pathkeys(), i, InvalidAttrNumber, IS_DUMMY_REL, IS_SIMPLE_REL, IsA, RelOptInfo::joininfo, lappend(), lfirst, RelOptInfo::max_attr, RelOptInfo::min_attr, NIL, RelOptInfo::nulling_relids, palloc0(), pfree(), relation_excluded_by_constraints(), RELOPT_BASEREL, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, RelOptInfo::rows, set_dummy_rel_pathlist(), set_rel_consider_parallel(), set_rel_size(), RelOptInfo::tuples, and PathTarget::width.
Referenced by set_rel_size().
◆ set_base_rel_consider_startup()
|
static |
Definition at line 259 of file allpaths.c.
260{
261 /*
262 * Since parameterized paths can only be used on the inside of a nestloop
263 * join plan, there is usually little value in considering fast-start
264 * plans for them. However, for relations that are on the RHS of a SEMI
265 * or ANTI join, a fast-start plan can be useful because we're only going
266 * to care about fetching one tuple anyway.
267 *
268 * To minimize growth of planning time, we currently restrict this to
269 * cases where the RHS is a single base relation, not a join; there is no
270 * provision for consider_param_startup to get set at all on joinrels.
271 * Also we don't worry about appendrels. costsize.c's costing rules for
272 * nestloop semi/antijoins don't consider such cases either.
273 */
275
277 {
279 int varno;
280
283 {
285
287 }
288 }
289}
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition bitmapset.c:714
Definition pathnodes.h:3191
References bms_get_singleton_member(), RelOptInfo::consider_param_startup, fb(), find_base_rel(), JOIN_ANTI, JOIN_SEMI, SpecialJoinInfo::jointype, lfirst, root, and SpecialJoinInfo::syn_righthand.
Referenced by make_one_rel().
◆ set_base_rel_pathlists()
|
static |
Definition at line 378 of file allpaths.c.
379{
380 Index rti;
381
383 {
385
386 /* there may be empty slots corresponding to non-baserel RTEs */
388 continue;
389
391
392 /* ignore RTEs that are "other rels" */
394 continue;
395
397 }
398}
References Assert, fb(), RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, root, and set_rel_pathlist().
Referenced by make_one_rel().
◆ set_base_rel_sizes()
|
static |
Definition at line 302 of file allpaths.c.
303{
304 Index rti;
305
307 {
310
311 /* there may be empty slots corresponding to non-baserel RTEs */
313 continue;
314
316
317 /* ignore RTEs that are "other rels" */
319 continue;
320
322
323 /*
324 * If parallelism is allowable for this query in general, see whether
325 * it's allowable for this rel in particular. We have to do this
326 * before set_rel_size(), because (a) if this rel is an inheritance
327 * parent, set_append_rel_size() will use and perhaps change the rel's
328 * consider_parallel flag, and (b) for some RTE types, set_rel_size()
329 * goes ahead and makes paths immediately.
330 */
333
335 }
336}
References Assert, fb(), RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, root, set_rel_consider_parallel(), and set_rel_size().
Referenced by make_one_rel().
◆ set_cte_pathlist()
|
static |
Definition at line 2996 of file allpaths.c.
2997{
3001 Index levelsup;
3002 List *pathkeys;
3005 int plan_id;
3007
3008 /*
3009 * Find the referenced CTE, and locate the path and plan previously made
3010 * for it.
3011 */
3012 levelsup = rte->ctelevelsup;
3014 while (levelsup-- > 0)
3015 {
3019 }
3020
3021 /*
3022 * Note: cte_plan_ids can be shorter than cteList, if we are still working
3023 * on planning the CTEs (ie, this is a side-reference from another CTE).
3024 * So we mustn't use forboth here.
3025 */
3026 ndx = 0;
3028 {
3030
3032 break;
3033 ndx++;
3034 }
3040 if (plan_id <= 0)
3042
3046
3047 /* Mark rel with estimated output rows, width, etc */
3049
3050 /* Convert the ctepath's pathkeys to outer query's representation */
3052 rel,
3053 ctepath->pathkeys,
3054 cteplan->targetlist);
3055
3056 /*
3057 * We don't support pushing join clauses into the quals of a CTE scan, but
3058 * it could still have required parameterization due to LATERAL refs in
3059 * its tlist.
3060 */
3062
3063 /* Generate appropriate path */
3065}
void set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel, double cte_rows)
Definition costsize.c:6222
List * convert_subquery_pathkeys(PlannerInfo *root, RelOptInfo *rel, List *subquery_pathkeys, List *subquery_tlist)
Definition pathkeys.c:1054
Path * create_ctescan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
Definition pathnode.c:1961
Definition parsenodes.h:1727
Definition plannodes.h:186
Definition pathnodes.h:297
References add_path(), Assert, convert_subquery_pathkeys(), create_ctescan_path(), CommonTableExpr::ctename, elog, ERROR, fb(), RelOptInfo::lateral_relids, lfirst, list_length(), list_nth(), list_nth_int(), root, and set_cte_size_estimates().
Referenced by set_rel_size().
◆ set_dummy_rel_pathlist()
|
static |
Definition at line 2305 of file allpaths.c.
2306{
2307 /* Set dummy size estimates --- we leave attr_widths[] as zeroes */
2308 rel->rows = 0;
2310
2311 /* Discard any pre-existing paths; no further need for them */
2314
2315 /* Set up the dummy path */
2318 0, false, -1));
2319
2320 /*
2321 * We set the cheapest-path fields immediately, just in case they were
2322 * pointing at some discarded path. This is redundant in current usage
2323 * because set_rel_pathlist will do it later, but it's cheap so we keep it
2324 * for safety and consistency with mark_dummy_rel.
2325 */
2326 set_cheapest(rel);
2327}
References add_path(), create_append_path(), fb(), RelOptInfo::lateral_relids, NIL, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, RelOptInfo::reltarget, RelOptInfo::rows, set_cheapest(), and PathTarget::width.
Referenced by set_append_rel_size(), set_rel_size(), and set_subquery_pathlist().
◆ set_foreign_pathlist()
|
static |
Definition at line 992 of file allpaths.c.
993{
994 /* Call the FDW's GetForeignPaths function to generate path(s) */
996}
References fb(), RelOptInfo::relid, and root.
Referenced by set_rel_pathlist().
◆ set_foreign_size()
|
static |
Definition at line 968 of file allpaths.c.
969{
970 /* Mark rel with estimated output rows, width, etc */
972
973 /* Let FDW adjust the size estimates, if it can */
975
976 /* ... but do not let it set the rows estimate to zero */
978
979 /*
980 * Also, make sure rel->tuples is not insane relative to rel->rows.
981 * Notably, this ensures sanity if pg_class.reltuples contains -1 and the
982 * FDW doesn't do anything to replace that.
983 */
985}
void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6322
References clamp_row_est(), fb(), Max, RelOptInfo::relid, root, RelOptInfo::rows, set_foreign_size_estimates(), and RelOptInfo::tuples.
Referenced by set_rel_size().
◆ set_function_pathlist()
|
static |
Definition at line 2885 of file allpaths.c.
2886{
2889
2890 /*
2891 * We don't support pushing join clauses into the quals of a function
2892 * scan, but it could still have required parameterization due to LATERAL
2893 * refs in the function expression.
2894 */
2896
2897 /*
2898 * The result is considered unordered unless ORDINALITY was used, in which
2899 * case it is ordered by the ordinal column (the last one). See if we
2900 * care, by checking for uses of that Var in equivalence classes.
2901 */
2903 {
2907
2908 /*
2909 * Is there a Var for it in rel's targetlist? If not, the query did
2910 * not reference the ordinality column, or at least not in any way
2911 * that would be interesting for sorting.
2912 */
2914 {
2916
2917 /* checking varno/varlevelsup is just paranoia */
2921 node->varlevelsup == 0)
2922 {
2923 var = node;
2924 break;
2925 }
2926 }
2927
2928 /*
2929 * Try to build pathkeys for this Var with int8 sorting. We tell
2930 * build_expression_pathkey not to build any new equivalence class; if
2931 * the Var isn't already mentioned in some EC, it means that nothing
2932 * cares about the ordering.
2933 */
2934 if (var)
2936 (Expr *) var,
2937 Int8LessOperator,
2938 rel->relids,
2939 false);
2940 }
2941
2942 /* Generate appropriate path */
2944 pathkeys, required_outer));
2945}
List * build_expression_pathkey(PlannerInfo *root, Expr *expr, Oid opno, Relids rel, bool create_it)
Definition pathkeys.c:1000
Path * create_functionscan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
Definition pathnode.c:1883
References add_path(), build_expression_pathkey(), create_functionscan_path(), PathTarget::exprs, fb(), IsA, RelOptInfo::lateral_relids, lfirst, RelOptInfo::max_attr, NIL, RelOptInfo::relid, RelOptInfo::relids, RelOptInfo::reltarget, root, Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by set_rel_pathlist().
◆ set_grouped_rel_pathlist()
|
static |
Definition at line 1368 of file allpaths.c.
1369{
1370 RelOptInfo *grouped_rel;
1371
1372 /*
1373 * If there are no aggregate expressions or grouping expressions, eager
1374 * aggregation is not possible.
1375 */
1378 return;
1379
1380 /* Add paths to the grouped base relation if one exists. */
1381 grouped_rel = rel->grouped_rel;
1382 if (grouped_rel)
1383 {
1385
1387 set_cheapest(grouped_rel);
1388 }
1389}
References Assert, generate_grouped_paths(), RelOptInfo::grouped_rel, IS_GROUPED_REL, NIL, root, and set_cheapest().
Referenced by set_rel_pathlist().
◆ set_namedtuplestore_pathlist()
|
static |
Definition at line 3075 of file allpaths.c.
3077{
3079
3080 /* Mark rel with estimated output rows, width, etc */
3082
3083 /*
3084 * We don't support pushing join clauses into the quals of a tuplestore
3085 * scan, but it could still have required parameterization due to LATERAL
3086 * refs in its tlist.
3087 */
3089
3090 /* Generate appropriate path */
3092}
void set_namedtuplestore_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6260
Path * create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition pathnode.c:1987
References add_path(), create_namedtuplestorescan_path(), fb(), RelOptInfo::lateral_relids, root, and set_namedtuplestore_size_estimates().
Referenced by set_rel_size().
◆ set_plain_rel_pathlist()
|
static |
Definition at line 822 of file allpaths.c.
823{
825
826 /*
827 * We don't support pushing join clauses into the quals of a seqscan, but
828 * it could still have required parameterization due to LATERAL refs in
829 * its tlist.
830 */
832
833 /*
834 * Consider TID scans.
835 *
836 * If create_tidscan_paths returns true, then a TID scan path is forced.
837 * This happens when rel->baserestrictinfo contains CurrentOfExpr, because
838 * the executor can't handle any other type of path for such queries.
839 * Hence, we return without adding any other paths.
840 */
842 return;
843
844 /* Consider sequential scan */
846
847 /* If appropriate, consider parallel sequential scan */
850
851 /* Consider index scans */
853}
static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel)
Definition allpaths.c:860
void create_index_paths(PlannerInfo *root, RelOptInfo *rel)
Definition indxpath.c:240
bool create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel)
Definition tidpath.c:497
References add_path(), RelOptInfo::consider_parallel, create_index_paths(), create_plain_partial_paths(), create_seqscan_path(), create_tidscan_paths(), fb(), RelOptInfo::lateral_relids, and root.
Referenced by set_rel_pathlist().
◆ set_plain_rel_size()
|
static |
Definition at line 626 of file allpaths.c.
627{
628 /*
629 * Test any partial indexes of rel for applicability. We must do this
630 * first since partial unique indexes can affect size estimates.
631 */
633
634 /* Mark rel with estimated output rows, width, etc */
636}
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:5496
void check_index_predicates(PlannerInfo *root, RelOptInfo *rel)
Definition indxpath.c:3941
References check_index_predicates(), root, and set_baserel_size_estimates().
Referenced by set_rel_size().
◆ set_rel_consider_parallel()
|
static |
Definition at line 643 of file allpaths.c.
645{
646 /*
647 * The flag has previously been initialized to false, so we can just
648 * return if it becomes clear that we can't safely set it.
649 */
651
652 /* Don't call this if parallelism is disallowed for the entire query. */
654
655 /* This should only be called for baserels and appendrel children. */
657
658 /* Assorted checks based on rtekind. */
660 {
662
663 /*
664 * Currently, parallel workers can't access the leader's temporary
665 * tables. We could possibly relax this if we wrote all of its
666 * local buffers at the start of the query and made no changes
667 * thereafter (maybe we could allow hint bit changes), and if we
668 * taught the workers to read them. Writing a large number of
669 * temporary buffers could be expensive, though, and we don't have
670 * the rest of the necessary infrastructure right now anyway. So
671 * for now, bail out if we see a temporary table.
672 */
674 return;
675
676 /*
677 * Table sampling can be pushed down to workers if the sample
678 * function and its arguments are safe.
679 */
681 {
683
685 return;
687 return;
688 }
689
690 /*
691 * Ask FDWs whether they can support performing a ForeignScan
692 * within a worker. Most often, the answer will be no. For
693 * example, if the nature of the FDW is such that it opens a TCP
694 * connection with a remote server, each parallel worker would end
695 * up with a separate connection, and these connections might not
696 * be appropriately coordinated between workers and the leader.
697 */
699 {
700 Assert(rel->fdwroutine);
701 if (!rel->fdwroutine->IsForeignScanParallelSafe)
702 return;
704 return;
705 }
706
707 /*
708 * There are additional considerations for appendrels, which we'll
709 * deal with in set_append_rel_size and set_append_rel_pathlist.
710 * For now, just set consider_parallel based on the rel's own
711 * quals and targetlist.
712 */
713 break;
714
716
717 /*
718 * There's no intrinsic problem with scanning a subquery-in-FROM
719 * (as distinct from a SubPlan or InitPlan) in a parallel worker.
720 * If the subquery doesn't happen to have any parallel-safe paths,
721 * then flagging it as consider_parallel won't change anything,
722 * but that's true for plain tables, too. We must set
723 * consider_parallel based on the rel's own quals and targetlist,
724 * so that if a subquery path is parallel-safe but the quals and
725 * projection we're sticking onto it are not, we correctly mark
726 * the SubqueryScanPath as not parallel-safe. (Note that
727 * set_subquery_pathlist() might push some of these quals down
728 * into the subquery itself, but that doesn't change anything.)
729 *
730 * We can't push sub-select containing LIMIT/OFFSET to workers as
731 * there is no guarantee that the row order will be fully
732 * deterministic, and applying LIMIT/OFFSET will lead to
733 * inconsistent results at the top-level. (In some cases, where
734 * the result is ordered, we could relax this restriction. But it
735 * doesn't currently seem worth expending extra effort to do so.)
736 */
737 {
739
741 return;
742 }
743 break;
744
746 /* Shouldn't happen; we're only considering baserels here. */
748 return;
749
751 /* Check for parallel-restricted functions. */
753 return;
754 break;
755
757 /* not parallel safe */
758 return;
759
761 /* Check for parallel-restricted functions. */
763 return;
764 break;
765
767
768 /*
769 * CTE tuplestores aren't shared among parallel workers, so we
770 * force all CTE scans to happen in the leader. Also, populating
771 * the CTE would require executing a subplan that's not available
772 * in the worker, might be parallel-restricted, and must get
773 * executed only once.
774 */
775 return;
776
778
779 /*
780 * tuplestore cannot be shared, at least without more
781 * infrastructure to support that.
782 */
783 return;
784
786 /* RESULT RTEs, in themselves, are no problem. */
787 break;
789 /* Shouldn't happen; we're only considering baserels here. */
791 return;
792 }
793
794 /*
795 * If there's anything in baserestrictinfo that's parallel-restricted, we
796 * give up on parallelizing access to this relation. We could consider
797 * instead postponing application of the restricted quals until we're
798 * above all the parallelism in the plan tree, but it's not clear that
799 * that would be a win in very many cases, and it might be tricky to make
800 * outer join clauses work correctly. It would likely break equivalence
801 * classes, too.
802 */
804 return;
805
806 /*
807 * Likewise, if the relation's outputs are not parallel-safe, give up.
808 * (Usually, they're just Vars, but sometimes they're not.)
809 */
811 return;
812
813 /* We have a winner. */
815}
References Assert, RelOptInfo::baserestrictinfo, castNode, RelOptInfo::consider_parallel, PathTarget::exprs, fb(), func_parallel(), get_rel_persistence(), is_parallel_safe(), IS_SIMPLE_REL, limit_needed(), RelOptInfo::reltarget, root, RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, and RTE_VALUES.
Referenced by set_append_rel_size(), and set_base_rel_sizes().
◆ set_rel_pathlist()
|
static |
Definition at line 514 of file allpaths.c.
516{
518 {
519 /* We already proved the relation empty, so nothing more to do */
520 }
522 {
523 /* It's an "append relation", process accordingly */
525 }
526 else
527 {
529 {
532 {
533 /* Foreign table */
535 }
537 {
538 /* Sampled relation */
540 }
541 else
542 {
543 /* Plain relation */
545 }
546 break;
548 /* Subquery --- fully handled during set_rel_size */
549 break;
551 /* RangeFunction */
553 break;
555 /* Table Function */
557 break;
559 /* Values list */
561 break;
563 /* CTE reference --- fully handled during set_rel_size */
564 break;
566 /* tuplestore reference --- fully handled during set_rel_size */
567 break;
569 /* simple Result --- fully handled during set_rel_size */
570 break;
571 default:
573 break;
574 }
575 }
576
577 /*
578 * Allow a plugin to editorialize on the set of Paths for this base
579 * relation. It could add new paths (such as CustomPaths) by calling
580 * add_path(), or add_partial_path() if parallel aware. It could also
581 * delete or modify paths added by the core code.
582 */
585
586 /*
587 * If this is a baserel, we should normally consider gathering any partial
588 * paths we may have created for it. We have to do this after calling the
589 * set_rel_pathlist_hook, else it cannot add partial paths to be included
590 * here.
591 *
592 * However, if this is an inheritance child, skip it. Otherwise, we could
593 * end up with a very large number of gather nodes, each trying to grab
594 * its own pool of workers. Instead, we'll consider gathering partial
595 * paths for the parent appendrel.
596 *
597 * Also, if this is the topmost scan/join rel, we postpone gathering until
598 * the final scan/join targetlist is available (see grouping_planner).
599 */
603
604 /* Now find the cheapest of the paths for this rel */
605 set_cheapest(rel);
606
607 /*
608 * If a grouped relation for this rel exists, build partial aggregation
609 * paths for it.
610 *
611 * Note that this can only happen after we've called set_cheapest() for
612 * this base rel, because we need its cheapest paths.
613 */
615
616#ifdef OPTIMIZER_DEBUG
617 pprint(rel);
618#endif
619}
static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:920
static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:992
static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition allpaths.c:1305
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition allpaths.c:3325
static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:2885
static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:822
static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:2972
static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:2952
static void set_grouped_rel_pathlist(PlannerInfo *root, RelOptInfo *rel)
Definition allpaths.c:1368
References bms_equal(), elog, ERROR, fb(), generate_useful_gather_paths(), IS_DUMMY_REL, pprint(), RelOptInfo::relids, RELOPT_BASEREL, RelOptInfo::reloptkind, root, RTE_CTE, RTE_FUNCTION, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RelOptInfo::rtekind, set_append_rel_pathlist(), set_cheapest(), set_foreign_pathlist(), set_function_pathlist(), set_grouped_rel_pathlist(), set_plain_rel_pathlist(), set_rel_pathlist_hook, set_tablefunc_pathlist(), set_tablesample_rel_pathlist(), and set_values_pathlist().
Referenced by set_append_rel_pathlist(), and set_base_rel_pathlists().
◆ set_rel_size()
|
static |
Definition at line 405 of file allpaths.c.
407{
410 {
411 /*
412 * We proved we don't need to scan the rel via constraint exclusion,
413 * so set up a single dummy path for it. Here we only check this for
414 * regular baserels; if it's an otherrel, CE was already checked in
415 * set_append_rel_size().
416 *
417 * In this case, we go ahead and set up the relation's path right away
418 * instead of leaving it for set_rel_pathlist to do. This is because
419 * we don't have a convention for marking a rel as dummy except by
420 * assigning a dummy path to it.
421 */
422 set_dummy_rel_pathlist(rel);
423 }
425 {
426 /* It's an "append relation", process accordingly */
428 }
429 else
430 {
432 {
435 {
436 /* Foreign table */
438 }
440 {
441 /*
442 * We could get here if asked to scan a partitioned table
443 * with ONLY. In that case we shouldn't scan any of the
444 * partitions, so mark it as a dummy rel.
445 */
446 set_dummy_rel_pathlist(rel);
447 }
449 {
450 /* Sampled relation */
452 }
453 else
454 {
455 /* Plain relation */
457 }
458 break;
460
461 /*
462 * Subqueries don't support making a choice between
463 * parameterized and unparameterized paths, so just go ahead
464 * and build their paths immediately.
465 */
467 break;
470 break;
473 break;
476 break;
478
479 /*
480 * CTEs don't support making a choice between parameterized
481 * and unparameterized paths, so just go ahead and build their
482 * paths immediately.
483 */
486 else
488 break;
490 /* Might as well just build the path immediately */
492 break;
494 /* Might as well just build the path immediately */
496 break;
497 default:
499 break;
500 }
501 }
502
503 /*
504 * We insist that all non-dummy rels have a nonzero rowcount estimate.
505 */
507}
static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition allpaths.c:2616
static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:3075
static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:880
static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:3102
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:3129
static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:968
static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:2996
static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition allpaths.c:1010
static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition allpaths.c:626
void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6130
void set_tablefunc_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6168
void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6190
References Assert, elog, ERROR, fb(), IS_DUMMY_REL, relation_excluded_by_constraints(), RELOPT_BASEREL, RelOptInfo::reloptkind, root, RelOptInfo::rows, RTE_CTE, RTE_FUNCTION, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RelOptInfo::rtekind, set_append_rel_size(), set_cte_pathlist(), set_dummy_rel_pathlist(), set_foreign_size(), set_function_size_estimates(), set_namedtuplestore_pathlist(), set_plain_rel_size(), set_result_pathlist(), set_subquery_pathlist(), set_tablefunc_size_estimates(), set_tablesample_rel_size(), set_values_size_estimates(), and set_worktable_pathlist().
Referenced by set_append_rel_size(), and set_base_rel_sizes().
◆ set_result_pathlist()
|
static |
Definition at line 3102 of file allpaths.c.
3104{
3106
3107 /* Mark rel with estimated output rows, width, etc */
3109
3110 /*
3111 * We don't support pushing join clauses into the quals of a Result scan,
3112 * but it could still have required parameterization due to LATERAL refs
3113 * in its tlist.
3114 */
3116
3117 /* Generate appropriate path */
3119}
void set_result_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6293
Path * create_resultscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition pathnode.c:2013
References add_path(), create_resultscan_path(), fb(), RelOptInfo::lateral_relids, root, and set_result_size_estimates().
Referenced by set_rel_size().
◆ set_subquery_pathlist()
|
static |
Definition at line 2616 of file allpaths.c.
2618{
2624 double tuple_fraction;
2628 char *plan_name;
2629
2630 /*
2631 * Must copy the Query so that planning doesn't mess up the RTE contents
2632 * (really really need to fix the planner to not scribble on its input,
2633 * someday ... but see remove_unused_subquery_outputs to start with).
2634 */
2635 subquery = copyObject(subquery);
2636
2637 /*
2638 * If it's a LATERAL subquery, it might contain some Vars of the current
2639 * query level, requiring it to be treated as parameterized, even though
2640 * we don't support pushing down join quals into subqueries.
2641 */
2643
2644 /*
2645 * Zero out result area for subquery_is_pushdown_safe, so that it can set
2646 * flags as needed while recursing. In particular, we need a workspace
2647 * for keeping track of the reasons why columns are unsafe to reference.
2648 * These reasons are stored in the bits inside unsafeFlags[i] when we
2649 * discover reasons that column i of the subquery is unsafe to be used in
2650 * a pushed-down qual.
2651 */
2655
2656 /*
2657 * If the subquery has the "security_barrier" flag, it means the subquery
2658 * originated from a view that must enforce row-level security. Then we
2659 * must not push down quals that contain leaky functions. (Ideally this
2660 * would be checked inside subquery_is_pushdown_safe, but since we don't
2661 * currently pass the RTE to that function, we must do it here.)
2662 */
2664
2665 /*
2666 * If there are any restriction clauses that have been attached to the
2667 * subquery relation, consider pushing them down to become WHERE or HAVING
2668 * quals of the subquery itself. This transformation is useful because it
2669 * may allow us to generate a better plan for the subquery than evaluating
2670 * all the subquery output rows and then filtering them.
2671 *
2672 * There are several cases where we cannot push down clauses. Restrictions
2673 * involving the subquery are checked by subquery_is_pushdown_safe().
2674 * Restrictions on individual clauses are checked by
2675 * qual_is_pushdown_safe(). Also, we don't want to push down
2676 * pseudoconstant clauses; better to have the gating node above the
2677 * subquery.
2678 *
2679 * Non-pushed-down clauses will get evaluated as qpquals of the
2680 * SubqueryScan node.
2681 *
2682 * XXX Are there any cases where we want to make a policy decision not to
2683 * push down a pushable qual, because it'd result in a worse plan?
2684 */
2687 {
2688 /* OK to consider pushing down individual quals */
2690 ListCell *l;
2691
2693 {
2696
2697 if (rinfo->pseudoconstant)
2698 {
2700 continue;
2701 }
2702
2704 {
2706 /* Push it down */
2708 break;
2709
2711
2712 /*
2713 * Since we can't push the qual down into the subquery,
2714 * check if it happens to reference a window function. If
2715 * so then it might be useful to use for the WindowAgg's
2716 * runCondition.
2717 */
2718 if (!subquery->hasWindowFuncs ||
2719 check_and_push_window_quals(subquery, clause,
2720 &run_cond_attrs))
2721 {
2722 /*
2723 * subquery has no window funcs or the clause is not a
2724 * suitable window run condition qual or it is, but
2725 * the original must also be kept in the upper query.
2726 */
2728 }
2729 break;
2730
2733 break;
2734 }
2735 }
2737 /* We don't bother recomputing baserestrict_min_security */
2738 }
2739
2741
2742 /*
2743 * The upper query might not use all the subquery's output columns; if
2744 * not, we can simplify. Pass the attributes that were pushed down into
2745 * WindowAgg run conditions to ensure we don't accidentally think those
2746 * are unused.
2747 */
2749
2750 /*
2751 * We can safely pass the outer tuple_fraction down to the subquery if the
2752 * outer level has no joining, aggregation, or sorting to do. Otherwise
2753 * we'd better tell the subquery to plan for full retrieval. (XXX This
2754 * could probably be made more intelligent ...)
2755 */
2757 parse->groupClause ||
2758 parse->groupingSets ||
2759 root->hasHavingQual ||
2760 parse->distinctClause ||
2761 parse->sortClause ||
2763 tuple_fraction = 0.0; /* default case */
2764 else
2765 tuple_fraction = root->tuple_fraction;
2766
2767 /* plan_params should not be in use in current query level */
2769
2770 /* Generate a subroot and Paths for the subquery */
2774
2775 /* Isolate the params needed by this specific subplan */
2778
2779 /*
2780 * It's possible that constraint exclusion proved the subquery empty. If
2781 * so, it's desirable to produce an unadorned dummy path so that we will
2782 * recognize appropriate optimizations at this query level.
2783 */
2785
2787 {
2788 set_dummy_rel_pathlist(rel);
2789 return;
2790 }
2791
2792 /*
2793 * Mark rel with estimated output rows, width, etc. Note that we have to
2794 * do this before generating outer-query paths, else cost_subqueryscan is
2795 * not happy.
2796 */
2798
2799 /*
2800 * Also detect whether the reltarget is trivial, so that we can pass that
2801 * info to cost_subqueryscan (rather than re-deriving it multiple times).
2802 * It's trivial if it fetches all the subplan output columns in order.
2803 */
2806 else
2807 {
2810 {
2812 Var *var;
2813
2815 {
2817 break;
2818 }
2819 var = (Var *) node;
2822 {
2824 break;
2825 }
2826 }
2827 }
2828
2829 /*
2830 * For each Path that subquery_planner produced, make a SubqueryScanPath
2831 * in the outer query.
2832 */
2834 {
2836 List *pathkeys;
2837
2838 /* Convert subpath's pathkeys to outer representation */
2840 rel,
2841 subpath->pathkeys,
2843
2844 /* Generate outer path using this subpath */
2847 trivial_pathtarget,
2848 pathkeys, required_outer));
2849 }
2850
2851 /* If outer rel allows parallelism, do same for partial paths. */
2853 {
2854 /* If consider_parallel is false, there should be no partial paths. */
2857
2858 /* Same for partial paths. */
2860 {
2862 List *pathkeys;
2863
2864 /* Convert subpath's pathkeys to outer representation */
2866 rel,
2867 subpath->pathkeys,
2869
2870 /* Generate outer path using this subpath */
2873 trivial_pathtarget,
2874 pathkeys,
2875 required_outer));
2876 }
2877 }
2878}
static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo, pushdown_safety_info *safetyInfo)
Definition allpaths.c:4377
static bool check_and_push_window_quals(Query *subquery, Node *clause, Bitmapset **run_cond_attrs)
Definition allpaths.c:2543
static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel, Bitmapset *extra_used_attrs)
Definition allpaths.c:4578
void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6050
SubqueryScanPath * create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, bool trivial_pathtarget, List *pathkeys, Relids required_outer)
Definition pathnode.c:1853
char * choose_plan_name(PlannerGlobal *glob, const char *name, bool always_number)
Definition planner.c:9022
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, char *plan_name, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction, SetOperationStmt *setops)
Definition planner.c:740
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition relnode.c:1606
Definition allpaths.c:63
References add_partial_path(), add_path(), Assert, RelOptInfo::baserestrictinfo, bms_is_empty, bms_membership(), BMS_MULTIPLE, check_and_push_window_quals(), choose_plan_name(), RestrictInfo::clause, RelOptInfo::consider_parallel, convert_subquery_pathkeys(), copyObject, create_subqueryscan_path(), PathTarget::exprs, fb(), fetch_upper_rel(), foreach_current_index, IS_DUMMY_REL, IsA, lappend(), RelOptInfo::lateral_relids, lfirst, list_length(), make_tlist_from_pathtarget(), NIL, palloc0(), parse(), pfree(), PUSHDOWN_SAFE, PUSHDOWN_UNSAFE, PUSHDOWN_WINDOWCLAUSE_RUNCOND, qual_is_pushdown_safe(), RelOptInfo::reltarget, remove_unused_subquery_outputs(), root, set_dummy_rel_pathlist(), set_subquery_size_estimates(), subpath(), RelOptInfo::subplan_params, subquery_is_pushdown_safe(), subquery_planner(), subquery_push_qual(), RelOptInfo::subroot, Query::targetList, UPPERREL_FINAL, Var::varattno, and Var::varno.
Referenced by set_rel_size().
◆ set_tablefunc_pathlist()
|
static |
Definition at line 2972 of file allpaths.c.
2973{
2975
2976 /*
2977 * We don't support pushing join clauses into the quals of a tablefunc
2978 * scan, but it could still have required parameterization due to LATERAL
2979 * refs in the function expression.
2980 */
2982
2983 /* Generate appropriate path */
2985 required_outer));
2986}
Path * create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition pathnode.c:1909
References add_path(), create_tablefuncscan_path(), fb(), RelOptInfo::lateral_relids, and root.
Referenced by set_rel_pathlist().
◆ set_tablesample_rel_pathlist()
|
static |
Definition at line 920 of file allpaths.c.
921{
923 Path *path;
924
925 /*
926 * We don't support pushing join clauses into the quals of a samplescan,
927 * but it could still have required parameterization due to LATERAL refs
928 * in its tlist or TABLESAMPLE arguments.
929 */
931
932 /* Consider sampled scan */
934
935 /*
936 * If the sampling method does not support repeatable scans, we must avoid
937 * plans that would scan the rel multiple times. Ideally, we'd simply
938 * avoid putting the rel on the inside of a nestloop join; but adding such
939 * a consideration to the planner seems like a great deal of complication
940 * to support an uncommon usage of second-rate sampling methods. Instead,
941 * if there is a risk that the query might perform an unsafe join, just
942 * wrap the SampleScan in a Materialize node. We can check for joins by
943 * counting the membership of all_query_rels (note that this correctly
944 * counts inheritance trees as single rels). If we're inside a subquery,
945 * we can't easily check whether a join might occur in the outer query, so
946 * just assume one is possible.
947 *
948 * GetTsmRoutine is relatively expensive compared to the other tests here,
949 * so check repeatable_across_scans last, even though that's a bit odd.
950 */
954 {
956 }
957
958 add_path(rel, path);
959
960 /* For the moment, at least, there are no other paths to consider */
961}
MaterialPath * create_material_path(RelOptInfo *rel, Path *subpath, bool enabled)
Definition pathnode.c:1656
Path * create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition pathnode.c:1006
References add_path(), bms_membership(), BMS_SINGLETON, create_material_path(), create_samplescan_path(), fb(), GetTsmRoutine(), RelOptInfo::lateral_relids, TsmRoutine::repeatable_across_scans, and root.
Referenced by set_rel_pathlist().
◆ set_tablesample_rel_size()
|
static |
Definition at line 880 of file allpaths.c.
881{
884 BlockNumber pages;
885 double tuples;
886
887 /*
888 * Test any partial indexes of rel for applicability. We must do this
889 * first since partial unique indexes can affect size estimates.
890 */
892
893 /*
894 * Call the sampling method's estimation function to estimate the number
895 * of pages it will read and the number of tuples it will return. (Note:
896 * we assume the function returns sane values.)
897 */
900 &pages, &tuples);
901
902 /*
903 * For the moment, because we will only consider a SampleScan path for the
904 * rel, it's okay to just overwrite the pages and tuples estimates for the
905 * whole relation. If we ever consider multiple path types for sampled
906 * rels, we'll need more complication.
907 */
908 rel->pages = pages;
909 rel->tuples = tuples;
910
911 /* Mark rel with estimated output rows, width, etc */
913}
Definition parsenodes.h:1402
Definition tsmapi.h:57
References check_index_predicates(), fb(), GetTsmRoutine(), RelOptInfo::pages, root, set_baserel_size_estimates(), and RelOptInfo::tuples.
Referenced by set_rel_size().
◆ set_values_pathlist()
|
static |
Definition at line 2952 of file allpaths.c.
2953{
2955
2956 /*
2957 * We don't support pushing join clauses into the quals of a values scan,
2958 * but it could still have required parameterization due to LATERAL refs
2959 * in the values expressions.
2960 */
2962
2963 /* Generate appropriate path */
2965}
Path * create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition pathnode.c:1935
References add_path(), create_valuesscan_path(), fb(), RelOptInfo::lateral_relids, and root.
Referenced by set_rel_pathlist().
◆ set_worktable_pathlist()
|
static |
Definition at line 3129 of file allpaths.c.
3130{
3133 Index levelsup;
3135
3136 /*
3137 * We need to find the non-recursive term's path, which is in the plan
3138 * level that's processing the recursive UNION, which is one level *below*
3139 * where the CTE comes from.
3140 */
3141 levelsup = rte->ctelevelsup;
3142 if (levelsup == 0) /* shouldn't happen */
3144 levelsup--;
3146 while (levelsup-- > 0)
3147 {
3151 }
3155
3156 /* Mark rel with estimated output rows, width, etc */
3158
3159 /*
3160 * We don't support pushing join clauses into the quals of a worktable
3161 * scan, but it could still have required parameterization due to LATERAL
3162 * refs in its tlist. (I'm not sure this is actually possible given the
3163 * restrictions on recursive references, but it's easy enough to support.)
3164 */
3166
3167 /* Generate appropriate path */
3169}
Path * create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition pathnode.c:2039
References add_path(), create_worktablescan_path(), elog, ERROR, fb(), RelOptInfo::lateral_relids, root, RelOptInfo::rows, and set_cte_size_estimates().
Referenced by set_rel_size().
◆ setup_simple_grouped_rels()
|
static |
Definition at line 344 of file allpaths.c.
345{
346 Index rti;
347
348 /*
349 * If there are no aggregate expressions or grouping expressions, eager
350 * aggregation is not possible.
351 */
354 return;
355
357 {
359
360 /* there may be empty slots corresponding to non-baserel RTEs */
362 continue;
363
366
368 }
369}
RelOptInfo * build_simple_grouped_rel(PlannerInfo *root, RelOptInfo *rel)
Definition relnode.c:437
References Assert, build_simple_grouped_rel(), fb(), IS_SIMPLE_REL, NIL, RelOptInfo::relid, and root.
Referenced by make_one_rel().
◆ standard_join_search()
| RelOptInfo * standard_join_search | ( | PlannerInfo * | root, |
| int | levels_needed, | ||
| List * | initial_rels | ||
| ) |
Definition at line 3885 of file allpaths.c.
3886{
3888 RelOptInfo *rel;
3889
3890 /*
3891 * This function cannot be invoked recursively within any one planning
3892 * problem, so join_rel_level[] can't be in use already.
3893 */
3895
3896 /*
3897 * We employ a simple "dynamic programming" algorithm: we first find all
3898 * ways to build joins of two jointree items, then all ways to build joins
3899 * of three items (from two-item joins and single items), then four-item
3900 * joins, and so on until we have considered all ways to join all the
3901 * items into one rel.
3902 *
3903 * root->join_rel_level[j] is a list of all the j-item rels. Initially we
3904 * set root->join_rel_level[1] to represent all the single-jointree-item
3905 * relations.
3906 */
3908
3909 root->join_rel_level[1] = initial_rels;
3910
3912 {
3914
3915 /*
3916 * Determine all possible pairs of relations to be joined at this
3917 * level, and build paths for making each one from every available
3918 * pair of lower-level relations.
3919 */
3921
3922 /*
3923 * Run generate_partitionwise_join_paths() and
3924 * generate_useful_gather_paths() for each just-processed joinrel. We
3925 * could not do this earlier because both regular and partial paths
3926 * can get added to a particular joinrel at multiple times within
3927 * join_search_one_level.
3928 *
3929 * After that, we're done creating paths for the joinrel, so run
3930 * set_cheapest().
3931 *
3932 * In addition, we also run generate_grouped_paths() for the grouped
3933 * relation of each just-processed joinrel, and run set_cheapest() for
3934 * the grouped relation afterwards.
3935 */
3937 {
3939
3941
3943
3944 /* Create paths for partitionwise joins. */
3946
3947 /*
3948 * Except for the topmost scan/join rel, consider gathering
3949 * partial paths. We'll do the same for the topmost scan/join rel
3950 * once we know the final targetlist (see grouping_planner's and
3951 * its call to apply_scanjoin_target_to_paths).
3952 */
3955
3956 /* Find and save the cheapest paths for this rel */
3957 set_cheapest(rel);
3958
3959 /*
3960 * Except for the topmost scan/join rel, consider generating
3961 * partial aggregation paths for the grouped relation on top of
3962 * the paths of this rel. After that, we're done creating paths
3963 * for the grouped relation, so run set_cheapest().
3964 */
3966 {
3968
3970
3972 set_cheapest(grouped_rel);
3973 }
3974
3975#ifdef OPTIMIZER_DEBUG
3976 pprint(rel);
3977#endif
3978 }
3979 }
3980
3981 /*
3982 * We should have a single rel at the final level.
3983 */
3987
3989
3991
3992 return rel;
3993}
void join_search_one_level(PlannerInfo *root, int level)
Definition joinrels.c:78
References Assert, bms_equal(), elog, ERROR, fb(), generate_grouped_paths(), generate_partitionwise_join_paths(), generate_useful_gather_paths(), RelOptInfo::grouped_rel, IS_GROUPED_REL, join_search_one_level(), lfirst, linitial, list_length(), NIL, palloc0(), pprint(), RelOptInfo::relids, root, and set_cheapest().
Referenced by make_rel_from_joinlist().
◆ subquery_is_pushdown_safe()
|
static |
Definition at line 4080 of file allpaths.c.
4082{
4084
4085 /* Check point 1 */
4087 return false;
4088
4089 /* Check point 6 */
4091 return false;
4092
4093 /* Check points 3, 4, and 5 */
4095 subquery->hasWindowFuncs ||
4096 subquery->hasTargetSRFs)
4098
4099 /*
4100 * If we're at a leaf query, check for unsafe expressions in its target
4101 * list, and mark any reasons why they're unsafe in unsafeFlags[].
4102 * (Non-leaf nodes in setop trees have only simple Vars in their tlists,
4103 * so no need to check them.)
4104 */
4107
4108 /* Are we at top level, or looking at a setop component? */
4110 {
4111 /* Top level, so check any component queries */
4114 safetyInfo))
4115 return false;
4116 }
4117 else
4118 {
4119 /* Setop component must not have more components (too weird) */
4121 return false;
4122 /* Check whether setop component output types match top level */
4126 topop->colTypes,
4127 safetyInfo);
4128 }
4129 return true;
4130}
static void compare_tlist_datatypes(List *tlist, List *colTypes, pushdown_safety_info *safetyInfo)
Definition allpaths.c:4301
static void check_output_expressions(Query *subquery, pushdown_safety_info *safetyInfo)
Definition allpaths.c:4205
References Assert, castNode, check_output_expressions(), compare_tlist_datatypes(), Query::distinctClause, fb(), Query::groupClause, Query::groupingSets, Query::limitCount, Query::limitOffset, recurse_pushdown_safe(), Query::setOperations, and Query::targetList.
Referenced by recurse_pushdown_safe(), and set_subquery_pathlist().
◆ subquery_push_qual()
|
static |
Definition at line 4478 of file allpaths.c.
4479{
4481 {
4482 /* Recurse to push it separately to each component query */
4484 rte, rti, qual);
4485 }
4486 else
4487 {
4488 /*
4489 * We need to replace Vars in the qual (which must refer to outputs of
4490 * the subquery) with copies of the subquery's targetlist expressions.
4491 * Note that at this point, any uplevel Vars in the qual should have
4492 * been replaced with Params, so they need no work.
4493 *
4494 * This step also ensures that when we are pushing into a setop tree,
4495 * each component query gets its own copy of the qual.
4496 */
4498 subquery->targetList,
4499 subquery->resultRelation,
4500 REPLACEVARS_REPORT_ERROR, 0,
4501 &subquery->hasSubLinks);
4502
4503 /*
4504 * Now attach the qual to the proper place: normally WHERE, but if the
4505 * subquery uses grouping or aggregation, put it in HAVING (since the
4506 * qual really refers to the group-result rows).
4507 */
4508 if (subquery->hasAggs || subquery->groupClause || subquery->groupingSets || subquery->havingQual)
4510 else
4513
4514 /*
4515 * We need not change the subquery's hasAggs or hasSubLinks flags,
4516 * since we can't be pushing down any aggregates that weren't there
4517 * before, and we don't push down subselects at all.
4518 */
4519 }
4520}
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:1958
References fb(), Query::groupClause, Query::groupingSets, Query::havingQual, Query::jointree, make_and_qual(), FromExpr::quals, recurse_push_qual(), REPLACEVARS_REPORT_ERROR, ReplaceVarsFromTargetList(), Query::setOperations, and Query::targetList.
Referenced by recurse_push_qual(), and set_subquery_pathlist().
◆ targetIsInAllPartitionLists()
|
static |
Definition at line 4334 of file allpaths.c.
4335{
4337
4339 {
4341
4343 return false;
4344 }
4345 return true;
4346}
References fb(), InvalidOid, lfirst, WindowClause::partitionClause, targetIsInSortList(), and Query::windowClause.
Referenced by check_output_expressions().
Variable Documentation
◆ enable_eager_aggregate
Definition at line 82 of file allpaths.c.
Referenced by setup_eager_aggregation().
◆ enable_geqo
Definition at line 81 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ geqo_threshold
| int geqo_threshold |
Definition at line 83 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ join_search_hook
| join_search_hook_type join_search_hook = NULL |
Definition at line 92 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ min_eager_agg_group_size
| double min_eager_agg_group_size |
Definition at line 84 of file allpaths.c.
Referenced by create_rel_agg_info().
◆ min_parallel_index_scan_size
| int min_parallel_index_scan_size |
Definition at line 86 of file allpaths.c.
Referenced by compute_parallel_worker(), and parallel_vacuum_compute_workers().
◆ min_parallel_table_scan_size
| int min_parallel_table_scan_size |
Definition at line 85 of file allpaths.c.
Referenced by compute_parallel_worker().
◆ set_rel_pathlist_hook
| set_rel_pathlist_hook_type set_rel_pathlist_hook = NULL |
Definition at line 89 of file allpaths.c.
Referenced by set_rel_pathlist().
