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/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 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 } |
Variables | |
| bool | enable_geqo = false |
| int | geqo_threshold |
| int | min_parallel_table_scan_size |
| int | min_parallel_index_scan_size |
| set_rel_pathlist_hook_type | set_rel_pathlist_hook = NULL |
| join_search_hook_type | join_search_hook = NULL |
Macro Definition Documentation
◆ UNSAFE_HAS_SET_FUNC
| #define UNSAFE_HAS_SET_FUNC (1 << 1) |
Definition at line 54 of file allpaths.c.
◆ UNSAFE_HAS_VOLATILE_FUNC
| #define UNSAFE_HAS_VOLATILE_FUNC (1 << 0) |
Definition at line 53 of file allpaths.c.
◆ UNSAFE_NOTIN_DISTINCTON_CLAUSE
| #define UNSAFE_NOTIN_DISTINCTON_CLAUSE (1 << 2) |
Definition at line 55 of file allpaths.c.
◆ UNSAFE_NOTIN_PARTITIONBY_CLAUSE
| #define UNSAFE_NOTIN_PARTITIONBY_CLAUSE (1 << 3) |
Definition at line 56 of file allpaths.c.
◆ UNSAFE_TYPE_MISMATCH
| #define UNSAFE_TYPE_MISMATCH (1 << 4) |
Definition at line 57 of file allpaths.c.
Typedef Documentation
◆ pushdown_safe_type
| typedef enum pushdown_safe_type pushdown_safe_type |
◆ pushdown_safety_info
| typedef struct pushdown_safety_info pushdown_safety_info |
Enumeration Type Documentation
◆ pushdown_safe_type
| enum pushdown_safe_type |
| Enumerator | |
|---|---|
| PUSHDOWN_UNSAFE | |
| PUSHDOWN_SAFE | |
| PUSHDOWN_WINDOWCLAUSE_RUNCOND | |
Definition at line 70 of file allpaths.c.
Function Documentation
◆ accumulate_append_subpath()
|
static |
Definition at line 2130 of file allpaths.c.
2131{
2133 {
2135
2137 {
2139 return;
2140 }
2141 else if (special_subpaths != NULL)
2142 {
2143 List *new_special_subpaths;
2144
2145 /* Split Parallel Append into partial and non-partial subpaths */
2146 *subpaths = list_concat(*subpaths,
2148 apath->first_partial_path));
2150 apath->first_partial_path);
2151 *special_subpaths = list_concat(*special_subpaths,
2152 new_special_subpaths);
2153 return;
2154 }
2155 }
2157 {
2159
2161 return;
2162 }
2163
2164 *subpaths = lappend(*subpaths, path);
2165}
Definition: pathnodes.h:2064
Definition: pg_list.h:54
Definition: pathnodes.h:2088
References AppendPath::first_partial_path, IsA, lappend(), list_concat(), list_copy_head(), list_copy_tail(), Path::parallel_aware, AppendPath::path, AppendPath::subpaths, and MergeAppendPath::subpaths.
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 1321 of file allpaths.c.
1323{
1325 bool subpaths_valid = true;
1327 bool startup_subpaths_valid = true;
1331 bool partial_subpaths_valid = true;
1332 bool pa_subpaths_valid;
1335 ListCell *l;
1336 double partial_rows = -1;
1337
1338 /* If appropriate, consider parallel append */
1340
1341 /*
1342 * For every non-dummy child, remember the cheapest path. Also, identify
1343 * all pathkeys (orderings) and parameterizations (required_outer sets)
1344 * available for the non-dummy member relations.
1345 */
1346 foreach(l, live_childrels)
1347 {
1349 ListCell *lcp;
1350 Path *cheapest_partial_path = NULL;
1351
1352 /*
1353 * If child has an unparameterized cheapest-total path, add that to
1354 * the unparameterized Append path we are constructing for the parent.
1355 * If not, there's no workable unparameterized path.
1356 *
1357 * With partitionwise aggregates, the child rel's pathlist may be
1358 * empty, so don't assume that a path exists here.
1359 */
1361 childrel->cheapest_total_path->param_info == NULL)
1363 &subpaths, NULL);
1364 else
1365 subpaths_valid = false;
1366
1367 /*
1368 * When the planner is considering cheap startup plans, we'll also
1369 * collect all the cheapest_startup_paths (if set) and build an
1370 * AppendPath containing those as subpaths.
1371 */
1373 {
1374 Path *cheapest_path;
1375
1376 /*
1377 * With an indication of how many tuples the query should provide,
1378 * the optimizer tries to choose the path optimal for that
1379 * specific number of tuples.
1380 */
1382 cheapest_path =
1383 get_cheapest_fractional_path(childrel,
1384 root->tuple_fraction);
1385 else
1386 cheapest_path = childrel->cheapest_startup_path;
1387
1388 /* cheapest_startup_path must not be a parameterized path. */
1389 Assert(cheapest_path->param_info == NULL);
1390 accumulate_append_subpath(cheapest_path,
1391 &startup_subpaths,
1392 NULL);
1393 }
1394 else
1395 startup_subpaths_valid = false;
1396
1397
1398 /* Same idea, but for a partial plan. */
1400 {
1402 accumulate_append_subpath(cheapest_partial_path,
1403 &partial_subpaths, NULL);
1404 }
1405 else
1406 partial_subpaths_valid = false;
1407
1408 /*
1409 * Same idea, but for a parallel append mixing partial and non-partial
1410 * paths.
1411 */
1412 if (pa_subpaths_valid)
1413 {
1414 Path *nppath = NULL;
1415
1416 nppath =
1418
1419 if (cheapest_partial_path == NULL && nppath == NULL)
1420 {
1421 /* Neither a partial nor a parallel-safe path? Forget it. */
1422 pa_subpaths_valid = false;
1423 }
1424 else if (nppath == NULL ||
1425 (cheapest_partial_path != NULL &&
1427 {
1428 /* Partial path is cheaper or the only option. */
1429 Assert(cheapest_partial_path != NULL);
1430 accumulate_append_subpath(cheapest_partial_path,
1431 &pa_partial_subpaths,
1432 &pa_nonpartial_subpaths);
1433 }
1434 else
1435 {
1436 /*
1437 * Either we've got only a non-partial path, or we think that
1438 * a single backend can execute the best non-partial path
1439 * faster than all the parallel backends working together can
1440 * execute the best partial path.
1441 *
1442 * It might make sense to be more aggressive here. Even if
1443 * the best non-partial path is more expensive than the best
1444 * partial path, it could still be better to choose the
1445 * non-partial path if there are several such paths that can
1446 * be given to different workers. For now, we don't try to
1447 * figure that out.
1448 */
1449 accumulate_append_subpath(nppath,
1450 &pa_nonpartial_subpaths,
1451 NULL);
1452 }
1453 }
1454
1455 /*
1456 * Collect lists of all the available path orderings and
1457 * parameterizations for all the children. We use these as a
1458 * heuristic to indicate which sort orderings and parameterizations we
1459 * should build Append and MergeAppend paths for.
1460 */
1462 {
1466
1467 /* Unsorted paths don't contribute to pathkey list */
1469 {
1470 ListCell *lpk;
1471 bool found = false;
1472
1473 /* Have we already seen this ordering? */
1474 foreach(lpk, all_child_pathkeys)
1475 {
1477
1479 childkeys) == PATHKEYS_EQUAL)
1480 {
1481 found = true;
1482 break;
1483 }
1484 }
1485 if (!found)
1486 {
1487 /* No, so add it to all_child_pathkeys */
1488 all_child_pathkeys = lappend(all_child_pathkeys,
1489 childkeys);
1490 }
1491 }
1492
1493 /* Unparameterized paths don't contribute to param-set list */
1494 if (childouter)
1495 {
1496 ListCell *lco;
1497 bool found = false;
1498
1499 /* Have we already seen this param set? */
1500 foreach(lco, all_child_outers)
1501 {
1503
1505 {
1506 found = true;
1507 break;
1508 }
1509 }
1510 if (!found)
1511 {
1512 /* No, so add it to all_child_outers */
1513 all_child_outers = lappend(all_child_outers,
1514 childouter);
1515 }
1516 }
1517 }
1518 }
1519
1520 /*
1521 * If we found unparameterized paths for all children, build an unordered,
1522 * unparameterized Append path for the rel. (Note: this is correct even
1523 * if we have zero or one live subpath due to constraint exclusion.)
1524 */
1525 if (subpaths_valid)
1528 -1));
1529
1530 /* build an AppendPath for the cheap startup paths, if valid */
1531 if (startup_subpaths_valid)
1534
1535 /*
1536 * Consider an append of unordered, unparameterized partial paths. Make
1537 * it parallel-aware if possible.
1538 */
1540 {
1541 AppendPath *appendpath;
1542 ListCell *lc;
1543 int parallel_workers = 0;
1544
1545 /* Find the highest number of workers requested for any subpath. */
1546 foreach(lc, partial_subpaths)
1547 {
1549
1551 }
1552 Assert(parallel_workers > 0);
1553
1554 /*
1555 * If the use of parallel append is permitted, always request at least
1556 * log2(# of children) workers. We assume it can be useful to have
1557 * extra workers in this case because they will be spread out across
1558 * the children. The precise formula is just a guess, but we don't
1559 * want to end up with a radically different answer for a table with N
1560 * partitions vs. an unpartitioned table with the same data, so the
1561 * use of some kind of log-scaling here seems to make some sense.
1562 */
1564 {
1565 parallel_workers = Max(parallel_workers,
1567 parallel_workers = Min(parallel_workers,
1569 }
1570 Assert(parallel_workers > 0);
1571
1572 /* Generate a partial append path. */
1574 NIL, NULL, parallel_workers,
1575 enable_parallel_append,
1576 -1);
1577
1578 /*
1579 * Make sure any subsequent partial paths use the same row count
1580 * estimate.
1581 */
1583
1584 /* Add the path. */
1586 }
1587
1588 /*
1589 * Consider a parallel-aware append using a mix of partial and non-partial
1590 * paths. (This only makes sense if there's at least one child which has
1591 * a non-partial path that is substantially cheaper than any partial path;
1592 * otherwise, we should use the append path added in the previous step.)
1593 */
1595 {
1596 AppendPath *appendpath;
1597 ListCell *lc;
1598 int parallel_workers = 0;
1599
1600 /*
1601 * Find the highest number of workers requested for any partial
1602 * subpath.
1603 */
1604 foreach(lc, pa_partial_subpaths)
1605 {
1607
1609 }
1610
1611 /*
1612 * Same formula here as above. It's even more important in this
1613 * instance because the non-partial paths won't contribute anything to
1614 * the planned number of parallel workers.
1615 */
1616 parallel_workers = Max(parallel_workers,
1618 parallel_workers = Min(parallel_workers,
1620 Assert(parallel_workers > 0);
1621
1623 pa_partial_subpaths,
1625 partial_rows);
1627 }
1628
1629 /*
1630 * Also build unparameterized ordered append paths based on the collected
1631 * list of child pathkeys.
1632 */
1633 if (subpaths_valid)
1635 all_child_pathkeys);
1636
1637 /*
1638 * Build Append paths for each parameterization seen among the child rels.
1639 * (This may look pretty expensive, but in most cases of practical
1640 * interest, the child rels will expose mostly the same parameterizations,
1641 * so that not that many cases actually get considered here.)
1642 *
1643 * The Append node itself cannot enforce quals, so all qual checking must
1644 * be done in the child paths. This means that to have a parameterized
1645 * Append path, we must have the exact same parameterization for each
1646 * child path; otherwise some children might be failing to check the
1647 * moved-down quals. To make them match up, we can try to increase the
1648 * parameterization of lesser-parameterized paths.
1649 */
1650 foreach(l, all_child_outers)
1651 {
1653 ListCell *lcr;
1654
1655 /* Select the child paths for an Append with this parameterization */
1656 subpaths = NIL;
1657 subpaths_valid = true;
1658 foreach(lcr, live_childrels)
1659 {
1662
1664 {
1665 /* failed to make a suitable path for this child */
1666 subpaths_valid = false;
1667 break;
1668 }
1669
1671 childrel,
1672 required_outer);
1674 {
1675 /* failed to make a suitable path for this child */
1676 subpaths_valid = false;
1677 break;
1678 }
1680 }
1681
1682 if (subpaths_valid)
1686 -1));
1687 }
1688
1689 /*
1690 * When there is only a single child relation, the Append path can inherit
1691 * any ordering available for the child rel's path, so that it's useful to
1692 * consider ordered partial paths. Above we only considered the cheapest
1693 * partial path for each child, but let's also make paths using any
1694 * partial paths that have pathkeys.
1695 */
1697 {
1699
1700 /* skip the cheapest partial path, since we already used that above */
1702 {
1704 AppendPath *appendpath;
1705
1706 /* skip paths with no pathkeys. */
1708 continue;
1709
1711 NIL, NULL,
1713 partial_rows);
1715 }
1716 }
1717}
static Path * get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: allpaths.c:2042
static void generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel, List *live_childrels, List *all_child_pathkeys)
Definition: allpaths.c:1747
static void accumulate_append_subpath(Path *path, List **subpaths, List **special_subpaths)
Definition: allpaths.c:2130
Assert(PointerIsAligned(start, uint64))
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:795
AppendPath * create_append_path(PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *partial_subpaths, List *pathkeys, Relids required_outer, int parallel_workers, bool parallel_aware, double rows)
Definition: pathnode.c:1300
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
Definition: planner.c:6529
Definition: bitmapset.h:50
Definition: pathnodes.h:1753
Definition: pathnodes.h:884
Definition: pg_list.h:46
References accumulate_append_subpath(), add_partial_path(), add_path(), Assert(), bms_equal(), RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, compare_pathkeys(), RelOptInfo::consider_parallel, RelOptInfo::consider_startup, create_append_path(), enable_parallel_append, 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, RelOptInfo::partial_pathlist, AppendPath::path, PATH_REQ_OUTER, Path::pathkeys, PATHKEYS_EQUAL, RelOptInfo::pathlist, pg_leftmost_one_pos32(), root, Path::rows, subpath(), and Path::total_cost.
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 2448 of file allpaths.c.
2450{
2452 bool keep_original = true;
2453 Var *var1;
2454 Var *var2;
2455
2456 /* We're only able to use OpExprs with 2 operands */
2458 return true;
2459
2461 return true;
2462
2463 /*
2464 * Currently, we restrict this optimization to strict OpExprs. The reason
2465 * for this is that during execution, once the runcondition becomes false,
2466 * we stop evaluating WindowFuncs. To avoid leaving around stale window
2467 * function result values, we set them to NULL. Having only strict
2468 * OpExprs here ensures that we properly filter out the tuples with NULLs
2469 * in the top-level WindowAgg.
2470 */
2471 set_opfuncid(opexpr);
2473 return true;
2474
2475 /*
2476 * Check for plain Vars that reference window functions in the subquery.
2477 * If we find any, we'll ask find_window_run_conditions() if 'opexpr' can
2478 * be used as part of the run condition.
2479 */
2480
2481 /* Check the left side of the OpExpr */
2484 {
2487
2489 opexpr, true, &keep_original,
2490 run_cond_attrs))
2491 return keep_original;
2492 }
2493
2494 /* and check the right side */
2497 {
2500
2502 opexpr, false, &keep_original,
2503 run_cond_attrs))
2504 return keep_original;
2505 }
2506
2507 return true;
2508}
static bool find_window_run_conditions(Query *subquery, RangeTblEntry *rte, Index rti, AttrNumber attno, WindowFunc *wfunc, OpExpr *opexpr, bool wfunc_left, bool *keep_original, Bitmapset **run_cond_attrs)
Definition: allpaths.c:2257
Definition: primnodes.h:831
Definition: primnodes.h:2216
Definition: primnodes.h:262
Definition: primnodes.h:581
References OpExpr::args, TargetEntry::expr, find_window_run_conditions(), func_strict(), if(), IsA, linitial, list_length(), list_nth(), lsecond, TargetEntry::resno, set_opfuncid(), Query::targetList, and Var::varattno.
Referenced by set_subquery_pathlist().
◆ check_output_expressions()
|
static |
Definition at line 3747 of file allpaths.c.
3748{
3749 ListCell *lc;
3750
3752 {
3754
3755 if (tle->resjunk)
3756 continue; /* ignore resjunk columns */
3757
3758 /* Functions returning sets are unsafe (point 1) */
3759 if (subquery->hasTargetSRFs &&
3761 UNSAFE_HAS_SET_FUNC) == 0 &&
3763 {
3765 continue;
3766 }
3767
3768 /* Volatile functions are unsafe (point 2) */
3770 UNSAFE_HAS_VOLATILE_FUNC) == 0 &&
3772 {
3774 continue;
3775 }
3776
3777 /* If subquery uses DISTINCT ON, check point 3 */
3778 if (subquery->hasDistinctOn &&
3780 UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
3782 {
3783 /* non-DISTINCT column, so mark it unsafe */
3785 continue;
3786 }
3787
3788 /* If subquery uses window functions, check point 4 */
3789 if (subquery->hasWindowFuncs &&
3791 UNSAFE_NOTIN_DISTINCTON_CLAUSE) == 0 &&
3792 !targetIsInAllPartitionLists(tle, subquery))
3793 {
3794 /* not present in all PARTITION BY clauses, so mark it unsafe */
3796 continue;
3797 }
3798 }
3799}
static bool targetIsInAllPartitionLists(TargetEntry *tle, Query *query)
Definition: allpaths.c:3852
bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList)
Definition: parse_clause.c:3635
Definition: nodes.h:135
References contain_volatile_functions(), Query::distinctClause, TargetEntry::expr, expression_returns_set(), InvalidOid, lfirst, TargetEntry::resno, targetIsInAllPartitionLists(), targetIsInSortList(), Query::targetList, UNSAFE_HAS_SET_FUNC, UNSAFE_HAS_VOLATILE_FUNC, UNSAFE_NOTIN_DISTINCTON_CLAUSE, UNSAFE_NOTIN_PARTITIONBY_CLAUSE, and pushdown_safety_info::unsafeFlags.
Referenced by subquery_is_pushdown_safe().
◆ compare_tlist_datatypes()
|
static |
Definition at line 3819 of file allpaths.c.
3821{
3822 ListCell *l;
3824
3825 foreach(l, tlist)
3826 {
3828
3829 if (tle->resjunk)
3830 continue; /* ignore resjunk columns */
3831 if (colType == NULL)
3835 colType = lnext(colTypes, colType);
3836 }
3837 if (colType != NULL)
3839}
References elog, ERROR, TargetEntry::expr, exprType(), lfirst, lfirst_oid, list_head(), lnext(), TargetEntry::resno, UNSAFE_TYPE_MISMATCH, and pushdown_safety_info::unsafeFlags.
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 4244 of file allpaths.c.
4246{
4247 int parallel_workers = 0;
4248
4249 /*
4250 * If the user has set the parallel_workers reloption, use that; otherwise
4251 * select a default number of workers.
4252 */
4254 parallel_workers = rel->rel_parallel_workers;
4255 else
4256 {
4257 /*
4258 * If the number of pages being scanned is insufficient to justify a
4259 * parallel scan, just return zero ... unless it's an inheritance
4260 * child. In that case, we want to generate a parallel path here
4261 * anyway. It might not be worthwhile just for this relation, but
4262 * when combined with all of its inheritance siblings it may well pay
4263 * off.
4264 */
4266 ((heap_pages >= 0 && heap_pages < min_parallel_table_scan_size) ||
4267 (index_pages >= 0 && index_pages < min_parallel_index_scan_size)))
4268 return 0;
4269
4270 if (heap_pages >= 0)
4271 {
4272 int heap_parallel_threshold;
4273 int heap_parallel_workers = 1;
4274
4275 /*
4276 * Select the number of workers based on the log of the size of
4277 * the relation. This probably needs to be a good deal more
4278 * sophisticated, but we need something here for now. Note that
4279 * the upper limit of the min_parallel_table_scan_size GUC is
4280 * chosen to prevent overflow here.
4281 */
4284 {
4285 heap_parallel_workers++;
4286 heap_parallel_threshold *= 3;
4287 if (heap_parallel_threshold > INT_MAX / 3)
4288 break; /* avoid overflow */
4289 }
4290
4291 parallel_workers = heap_parallel_workers;
4292 }
4293
4294 if (index_pages >= 0)
4295 {
4296 int index_parallel_workers = 1;
4297 int index_parallel_threshold;
4298
4299 /* same calculation as for heap_pages above */
4302 {
4303 index_parallel_workers++;
4304 index_parallel_threshold *= 3;
4305 if (index_parallel_threshold > INT_MAX / 3)
4306 break; /* avoid overflow */
4307 }
4308
4309 if (parallel_workers > 0)
4310 parallel_workers = Min(parallel_workers, index_parallel_workers);
4311 else
4312 parallel_workers = index_parallel_workers;
4313 }
4314 }
4315
4316 /* In no case use more than caller supplied maximum number of workers */
4317 parallel_workers = Min(parallel_workers, max_workers);
4318
4319 return parallel_workers;
4320}
References 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(), and plan_create_index_workers().
◆ create_partial_bitmap_paths()
| void create_partial_bitmap_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | rel, | ||
| Path * | bitmapqual | ||
| ) |
Definition at line 4208 of file allpaths.c.
4210{
4211 int parallel_workers;
4212 double pages_fetched;
4213
4214 /* Compute heap pages for bitmap heap scan */
4216 NULL, NULL);
4217
4218 parallel_workers = compute_parallel_worker(rel, pages_fetched, -1,
4220
4221 if (parallel_workers <= 0)
4222 return;
4223
4225 bitmapqual, rel->lateral_relids, 1.0, parallel_workers));
4226}
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition: allpaths.c:4244
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, double loop_count, Cost *cost_p, double *tuples_p)
Definition: costsize.c:6500
BitmapHeapPath * create_bitmap_heap_path(PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
Definition: pathnode.c:1098
References add_partial_path(), compute_bitmap_pages(), compute_parallel_worker(), create_bitmap_heap_path(), RelOptInfo::lateral_relids, max_parallel_workers_per_gather, and root.
Referenced by create_index_paths().
◆ create_plain_partial_paths()
|
static |
Definition at line 806 of file allpaths.c.
807{
808 int parallel_workers;
809
812
813 /* If any limit was set to zero, the user doesn't want a parallel scan. */
814 if (parallel_workers <= 0)
815 return;
816
817 /* Add an unordered partial path based on a parallel sequential scan. */
819}
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
Definition: pathnode.c:983
References add_partial_path(), compute_parallel_worker(), create_seqscan_path(), max_parallel_workers_per_gather, RelOptInfo::pages, and root.
Referenced by set_plain_rel_pathlist().
◆ find_window_run_conditions()
|
static |
Definition at line 2257 of file allpaths.c.
2261{
2262 Oid prosupport;
2263 Expr *otherexpr;
2264 SupportRequestWFuncMonotonic req;
2265 SupportRequestWFuncMonotonic *res;
2266 WindowClause *wclause;
2267 List *opinfos;
2268 OpExpr *runopexpr;
2269 Oid runoperator;
2270 ListCell *lc;
2271
2272 *keep_original = true;
2273
2276
2277 /* we can only work with window functions */
2279 return false;
2280
2281 /* can't use it if there are subplans in the WindowFunc */
2283 return false;
2284
2285 prosupport = get_func_support(wfunc->winfnoid);
2286
2287 /* Check if there's a support function for 'wfunc' */
2289 return false;
2290
2291 /* get the Expr from the other side of the OpExpr */
2292 if (wfunc_left)
2294 else
2296
2297 /*
2298 * The value being compared must not change during the evaluation of the
2299 * window partition.
2300 */
2302 return false;
2303
2304 /* find the window clause belonging to the window function */
2306 wfunc->winref - 1);
2307
2308 req.type = T_SupportRequestWFuncMonotonic;
2309 req.window_func = wfunc;
2310 req.window_clause = wclause;
2311
2312 /* call the support function */
2313 res = (SupportRequestWFuncMonotonic *)
2315 PointerGetDatum(&req)));
2316
2317 /*
2318 * Nothing to do if the function is neither monotonically increasing nor
2319 * monotonically decreasing.
2320 */
2322 return false;
2323
2324 runopexpr = NULL;
2325 runoperator = InvalidOid;
2327
2328 foreach(lc, opinfos)
2329 {
2332
2333 /* handle < / <= */
2335 {
2336 /*
2337 * < / <= is supported for monotonically increasing functions in
2338 * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
2339 * for monotonically decreasing functions.
2340 */
2343 {
2344 *keep_original = false;
2345 runopexpr = opexpr;
2346 runoperator = opexpr->opno;
2347 }
2348 break;
2349 }
2350 /* handle > / >= */
2352 {
2353 /*
2354 * > / >= is supported for monotonically decreasing functions in
2355 * the form <wfunc> op <pseudoconst> and <pseudoconst> op <wfunc>
2356 * for monotonically increasing functions.
2357 */
2360 {
2361 *keep_original = false;
2362 runopexpr = opexpr;
2363 runoperator = opexpr->opno;
2364 }
2365 break;
2366 }
2367 /* handle = */
2369 {
2370 CompareType newcmptype;
2371
2372 /*
2373 * When both monotonically increasing and decreasing then the
2374 * return value of the window function will be the same each time.
2375 * We can simply use 'opexpr' as the run condition without
2376 * modifying it.
2377 */
2379 {
2380 *keep_original = false;
2381 runopexpr = opexpr;
2382 runoperator = opexpr->opno;
2383 break;
2384 }
2385
2386 /*
2387 * When monotonically increasing we make a qual with <wfunc> <=
2388 * <value> or <value> >= <wfunc> in order to filter out values
2389 * which are above the value in the equality condition. For
2390 * monotonically decreasing functions we want to filter values
2391 * below the value in the equality condition.
2392 */
2395 else
2397
2398 /* We must keep the original equality qual */
2399 *keep_original = true;
2400 runopexpr = opexpr;
2401
2402 /* determine the operator to use for the WindowFuncRunCondition */
2404 opinfo->oplefttype,
2405 opinfo->oprighttype,
2406 newcmptype);
2407 break;
2408 }
2409 }
2410
2411 if (runopexpr != NULL)
2412 {
2413 WindowFuncRunCondition *wfuncrc;
2414
2416 wfuncrc->opno = runoperator;
2417 wfuncrc->inputcollid = runopexpr->inputcollid;
2418 wfuncrc->wfunc_left = wfunc_left;
2420
2421 wfunc->runCondition = lappend(wfunc->runCondition, wfuncrc);
2422
2423 /* record that this attno was used in a run condition */
2424 *run_cond_attrs = bms_add_member(*run_cond_attrs,
2425 attno - FirstLowInvalidHeapAttributeNumber);
2426 return true;
2427 }
2428
2429 /* unsupported OpExpr */
2430 return false;
2431}
Oid get_opfamily_member_for_cmptype(Oid opfamily, Oid lefttype, Oid righttype, CompareType cmptype)
Definition: lsyscache.c:196
Definition: primnodes.h:189
Definition: lsyscache.h:26
Definition: primnodes.h:1199
Definition: supportnodes.h:291
struct WindowClause * window_clause
Definition: supportnodes.h:296
Definition: parsenodes.h:1551
Definition: primnodes.h:614
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27
References arg, WindowFuncRunCondition::arg, OpExpr::args, bms_add_member(), OpIndexInterpretation::cmptype, COMPARE_EQ, COMPARE_GE, COMPARE_GT, COMPARE_LE, COMPARE_LT, contain_subplans(), copyObject, DatumGetPointer(), 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, OpIndexInterpretation::opfamily_id, OpIndexInterpretation::oplefttype, WindowFuncRunCondition::opno, OpExpr::opno, OpIndexInterpretation::oprighttype, PointerGetDatum(), SupportRequestWFuncMonotonic::type, WindowFuncRunCondition::wfunc_left, SupportRequestWFuncMonotonic::window_clause, SupportRequestWFuncMonotonic::window_func, 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 3093 of file allpaths.c.
3094{
3095 Path *cheapest_partial_path;
3096 Path *simple_gather_path;
3097 ListCell *lc;
3098 double rows;
3099 double *rowsp = NULL;
3100
3101 /* If there are no partial paths, there's nothing to do here. */
3103 return;
3104
3105 /* Should we override the rel's rowcount estimate? */
3106 if (override_rows)
3107 rowsp = &rows;
3108
3109 /*
3110 * The output of Gather is always unsorted, so there's only one partial
3111 * path of interest: the cheapest one. That will be the one at the front
3112 * of partial_pathlist because of the way add_partial_path works.
3113 */
3115 rows = compute_gather_rows(cheapest_partial_path);
3116 simple_gather_path = (Path *)
3118 NULL, rowsp);
3119 add_path(rel, simple_gather_path);
3120
3121 /*
3122 * For each useful ordering, we can consider an order-preserving Gather
3123 * Merge.
3124 */
3126 {
3128 GatherMergePath *path;
3129
3131 continue;
3132
3135 subpath->pathkeys, NULL, rowsp);
3137 }
3138}
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
Definition: pathnode.c:1962
GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
Definition: pathnode.c:2044
Definition: pathnodes.h:2186
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_gather_path(), lfirst, linitial, NIL, RelOptInfo::partial_pathlist, GatherMergePath::path, RelOptInfo::reltarget, root, and subpath().
Referenced by generate_useful_gather_paths().
◆ generate_orderedappend_paths()
|
static |
Definition at line 1747 of file allpaths.c.
1750{
1751 ListCell *lcp;
1754 bool partition_pathkeys_partial = true;
1755 bool partition_pathkeys_desc_partial = true;
1756
1757 /*
1758 * Some partitioned table setups may allow us to use an Append node
1759 * instead of a MergeAppend. This is possible in cases such as RANGE
1760 * partitioned tables where it's guaranteed that an earlier partition must
1761 * contain rows which come earlier in the sort order. To detect whether
1762 * this is relevant, build pathkey descriptions of the partition ordering,
1763 * for both forward and reverse scans.
1764 */
1767 {
1769 ForwardScanDirection,
1770 &partition_pathkeys_partial);
1771
1773 BackwardScanDirection,
1774 &partition_pathkeys_desc_partial);
1775
1776 /*
1777 * You might think we should truncate_useless_pathkeys here, but
1778 * allowing partition keys which are a subset of the query's pathkeys
1779 * can often be useful. For example, consider a table partitioned by
1780 * RANGE (a, b), and a query with ORDER BY a, b, c. If we have child
1781 * paths that can produce the a, b, c ordering (perhaps via indexes on
1782 * (a, b, c)) then it works to consider the appendrel output as
1783 * ordered by a, b, c.
1784 */
1785 }
1786
1787 /* Now consider each interesting sort ordering */
1788 foreach(lcp, all_child_pathkeys)
1789 {
1794 bool startup_neq_total = false;
1795 bool match_partition_order;
1796 bool match_partition_order_desc;
1797 int end_index;
1798 int first_index;
1799 int direction;
1800
1801 /*
1802 * Determine if this sort ordering matches any partition pathkeys we
1803 * have, for both ascending and descending partition order. If the
1804 * partition pathkeys happen to be contained in pathkeys then it still
1805 * works, as described above, providing that the partition pathkeys
1806 * are complete and not just a prefix of the partition keys. (In such
1807 * cases we'll be relying on the child paths to have sorted the
1808 * lower-order columns of the required pathkeys.)
1809 */
1810 match_partition_order =
1811 pathkeys_contained_in(pathkeys, partition_pathkeys) ||
1812 (!partition_pathkeys_partial &&
1813 pathkeys_contained_in(partition_pathkeys, pathkeys));
1814
1815 match_partition_order_desc = !match_partition_order &&
1816 (pathkeys_contained_in(pathkeys, partition_pathkeys_desc) ||
1817 (!partition_pathkeys_desc_partial &&
1818 pathkeys_contained_in(partition_pathkeys_desc, pathkeys)));
1819
1820 /*
1821 * When the required pathkeys match the reverse of the partition
1822 * order, we must build the list of paths in reverse starting with the
1823 * last matching partition first. We can get away without making any
1824 * special cases for this in the loop below by just looping backward
1825 * over the child relations in this case.
1826 */
1827 if (match_partition_order_desc)
1828 {
1829 /* loop backward */
1830 first_index = list_length(live_childrels) - 1;
1831 end_index = -1;
1832 direction = -1;
1833
1834 /*
1835 * Set this to true to save us having to check for
1836 * match_partition_order_desc in the loop below.
1837 */
1838 match_partition_order = true;
1839 }
1840 else
1841 {
1842 /* for all other case, loop forward */
1843 first_index = 0;
1844 end_index = list_length(live_childrels);
1845 direction = 1;
1846 }
1847
1848 /* Select the child paths for this ordering... */
1850 {
1852 Path *cheapest_startup,
1853 *cheapest_total,
1854 *cheapest_fractional = NULL;
1855
1856 /* Locate the right paths, if they are available. */
1857 cheapest_startup =
1859 pathkeys,
1860 NULL,
1861 STARTUP_COST,
1862 false);
1863 cheapest_total =
1865 pathkeys,
1866 NULL,
1867 TOTAL_COST,
1868 false);
1869
1870 /*
1871 * If we can't find any paths with the right order just use the
1872 * cheapest-total path; we'll have to sort it later.
1873 */
1874 if (cheapest_startup == NULL || cheapest_total == NULL)
1875 {
1876 cheapest_startup = cheapest_total =
1877 childrel->cheapest_total_path;
1878 /* Assert we do have an unparameterized path for this child */
1879 Assert(cheapest_total->param_info == NULL);
1880 }
1881
1882 /*
1883 * When building a fractional path, determine a cheapest
1884 * fractional path for each child relation too. Looking at startup
1885 * and total costs is not enough, because the cheapest fractional
1886 * path may be dominated by two separate paths (one for startup,
1887 * one for total).
1888 *
1889 * When needed (building fractional path), determine the cheapest
1890 * fractional path too.
1891 */
1893 {
1895
1896 /*
1897 * Merge Append considers only live children relations. Dummy
1898 * relations must be filtered out before.
1899 */
1901
1902 /* Convert absolute limit to a path fraction */
1903 if (path_fraction >= 1.0)
1904 path_fraction /= childrel->rows;
1905
1906 cheapest_fractional =
1908 pathkeys,
1909 NULL,
1910 path_fraction);
1911
1912 /*
1913 * If we found no path with matching pathkeys, use the
1914 * cheapest total path instead.
1915 *
1916 * XXX We might consider partially sorted paths too (with an
1917 * incremental sort on top). But we'd have to build all the
1918 * incremental paths, do the costing etc.
1919 */
1920 if (!cheapest_fractional)
1921 cheapest_fractional = cheapest_total;
1922 }
1923
1924 /*
1925 * Notice whether we actually have different paths for the
1926 * "cheapest" and "total" cases; frequently there will be no point
1927 * in two create_merge_append_path() calls.
1928 */
1929 if (cheapest_startup != cheapest_total)
1930 startup_neq_total = true;
1931
1932 /*
1933 * Collect the appropriate child paths. The required logic varies
1934 * for the Append and MergeAppend cases.
1935 */
1936 if (match_partition_order)
1937 {
1938 /*
1939 * We're going to make a plain Append path. We don't need
1940 * most of what accumulate_append_subpath would do, but we do
1941 * want to cut out child Appends or MergeAppends if they have
1942 * just a single subpath (and hence aren't doing anything
1943 * useful).
1944 */
1945 cheapest_startup = get_singleton_append_subpath(cheapest_startup);
1946 cheapest_total = get_singleton_append_subpath(cheapest_total);
1947
1948 startup_subpaths = lappend(startup_subpaths, cheapest_startup);
1949 total_subpaths = lappend(total_subpaths, cheapest_total);
1950
1951 if (cheapest_fractional)
1952 {
1953 cheapest_fractional = get_singleton_append_subpath(cheapest_fractional);
1954 fractional_subpaths = lappend(fractional_subpaths, cheapest_fractional);
1955 }
1956 }
1957 else
1958 {
1959 /*
1960 * Otherwise, rely on accumulate_append_subpath to collect the
1961 * child paths for the MergeAppend.
1962 */
1963 accumulate_append_subpath(cheapest_startup,
1964 &startup_subpaths, NULL);
1965 accumulate_append_subpath(cheapest_total,
1966 &total_subpaths, NULL);
1967
1968 if (cheapest_fractional)
1969 accumulate_append_subpath(cheapest_fractional,
1970 &fractional_subpaths, NULL);
1971 }
1972 }
1973
1974 /* ... and build the Append or MergeAppend paths */
1975 if (match_partition_order)
1976 {
1977 /* We only need Append */
1979 rel,
1980 startup_subpaths,
1981 NIL,
1982 pathkeys,
1983 NULL,
1984 0,
1985 false,
1986 -1));
1987 if (startup_neq_total)
1989 rel,
1990 total_subpaths,
1991 NIL,
1992 pathkeys,
1993 NULL,
1994 0,
1995 false,
1996 -1));
1997
1998 if (fractional_subpaths)
2000 rel,
2001 fractional_subpaths,
2002 NIL,
2003 pathkeys,
2004 NULL,
2005 0,
2006 false,
2007 -1));
2008 }
2009 else
2010 {
2011 /* We need MergeAppend */
2013 rel,
2014 startup_subpaths,
2015 pathkeys,
2016 NULL));
2017 if (startup_neq_total)
2019 rel,
2020 total_subpaths,
2021 pathkeys,
2022 NULL));
2023
2024 if (fractional_subpaths)
2026 rel,
2027 fractional_subpaths,
2028 pathkeys,
2029 NULL));
2030 }
2031 }
2032}
static Path * get_singleton_append_subpath(Path *path)
Definition: allpaths.c:2175
bool partitions_are_ordered(PartitionBoundInfo boundinfo, Bitmapset *live_parts)
Definition: partbounds.c:2852
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:1471
References accumulate_append_subpath(), add_path(), Assert(), BackwardScanDirection, build_partition_pathkeys(), RelOptInfo::cheapest_total_path, create_append_path(), create_merge_append_path(), 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(), RelOptInfo::pathlist, root, RelOptInfo::rows, 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 4332 of file allpaths.c.
4333{
4335 int cnt_parts;
4336 int num_parts;
4337 RelOptInfo **part_rels;
4338
4339 /* Handle only join relations here. */
4341 return;
4342
4343 /* We've nothing to do if the relation is not partitioned. */
4345 return;
4346
4347 /* The relation should have consider_partitionwise_join set. */
4349
4350 /* Guard against stack overflow due to overly deep partition hierarchy. */
4351 check_stack_depth();
4352
4353 num_parts = rel->nparts;
4354 part_rels = rel->part_rels;
4355
4356 /* Collect non-dummy child-joins. */
4357 for (cnt_parts = 0; cnt_parts < num_parts; cnt_parts++)
4358 {
4359 RelOptInfo *child_rel = part_rels[cnt_parts];
4360
4361 /* If it's been pruned entirely, it's certainly dummy. */
4362 if (child_rel == NULL)
4363 continue;
4364
4365 /* Make partitionwise join paths for this partitioned child-join. */
4367
4368 /* If we failed to make any path for this child, we must give up. */
4370 {
4371 /*
4372 * Mark the parent joinrel as unpartitioned so that later
4373 * functions treat it correctly.
4374 */
4375 rel->nparts = 0;
4376 return;
4377 }
4378
4379 /* Else, identify the cheapest path for it. */
4380 set_cheapest(child_rel);
4381
4382 /* Dummy children need not be scanned, so ignore those. */
4384 continue;
4385
4386#ifdef OPTIMIZER_DEBUG
4387 pprint(child_rel);
4388#endif
4389
4390 live_children = lappend(live_children, child_rel);
4391 }
4392
4393 /* If all child-joins are dummy, parent join is also dummy. */
4394 if (!live_children)
4395 {
4396 mark_dummy_rel(rel);
4397 return;
4398 }
4399
4400 /* Build additional paths for this rel from child-join paths. */
4402 list_free(live_children);
4403}
void generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: allpaths.c:4332
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
Definition: allpaths.c:1321
References add_paths_to_append_rel(), Assert(), check_stack_depth(), RelOptInfo::consider_partitionwise_join, generate_partitionwise_join_paths(), IS_DUMMY_REL, IS_JOIN_REL, IS_PARTITIONED_REL, lappend(), list_free(), mark_dummy_rel(), NIL, RelOptInfo::nparts, RelOptInfo::pathlist, pprint(), root, and set_cheapest().
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 3230 of file allpaths.c.
3231{
3232 ListCell *lc;
3233 double rows;
3234 double *rowsp = NULL;
3236 Path *cheapest_partial_path = NULL;
3237
3238 /* If there are no partial paths, there's nothing to do here. */
3240 return;
3241
3242 /* Should we override the rel's rowcount estimate? */
3243 if (override_rows)
3244 rowsp = &rows;
3245
3246 /* generate the regular gather (merge) paths */
3248
3249 /* consider incremental sort for interesting orderings */
3251
3252 /* used for explicit (full) sort paths */
3254
3255 /*
3256 * Consider sorted paths for each interesting ordering. We generate both
3257 * incremental and full sort.
3258 */
3259 foreach(lc, useful_pathkeys_list)
3260 {
3262 ListCell *lc2;
3263 bool is_sorted;
3264 int presorted_keys;
3265
3267 {
3269 GatherMergePath *path;
3270
3271 is_sorted = pathkeys_count_contained_in(useful_pathkeys,
3272 subpath->pathkeys,
3273 &presorted_keys);
3274
3275 /*
3276 * We don't need to consider the case where a subpath is already
3277 * fully sorted because generate_gather_paths already creates a
3278 * gather merge path for every subpath that has pathkeys present.
3279 *
3280 * But since the subpath is already sorted, we know we don't need
3281 * to consider adding a sort (full or incremental) on top of it,
3282 * so we can continue here.
3283 */
3284 if (is_sorted)
3285 continue;
3286
3287 /*
3288 * Try at least sorting the cheapest path and also try
3289 * incrementally sorting any path which is partially sorted
3290 * already (no need to deal with paths which have presorted keys
3291 * when incremental sort is disabled unless it's the cheapest
3292 * input path).
3293 */
3295 (presorted_keys == 0 || !enable_incremental_sort))
3296 continue;
3297
3298 /*
3299 * Consider regular sort for any path that's not presorted or if
3300 * incremental sort is disabled. We've no need to consider both
3301 * sort and incremental sort on the same path. We assume that
3302 * incremental sort is always faster when there are presorted
3303 * keys.
3304 *
3305 * This is not redundant with the gather paths created in
3306 * generate_gather_paths, because that doesn't generate ordered
3307 * output. Here we add an explicit sort to match the useful
3308 * ordering.
3309 */
3311 {
3313 rel,
3314 subpath,
3315 useful_pathkeys,
3316 -1.0);
3317 }
3318 else
3320 rel,
3321 subpath,
3322 useful_pathkeys,
3323 presorted_keys,
3324 -1);
3327 subpath,
3328 rel->reltarget,
3329 subpath->pathkeys,
3330 NULL,
3331 rowsp);
3332
3334 }
3335 }
3336}
static List * get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel, bool require_parallel_safe)
Definition: allpaths.c:3162
void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition: allpaths.c:3093
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
Definition: pathkeys.c:558
IncrementalSortPath * create_incremental_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
Definition: pathnode.c:3035
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
Definition: pathnode.c:3085
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, 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(), gather_grouping_paths(), merge_clump(), set_rel_pathlist(), and standard_join_search().
◆ get_cheapest_parameterized_child_path()
|
static |
Definition at line 2042 of file allpaths.c.
2044{
2045 Path *cheapest;
2046 ListCell *lc;
2047
2048 /*
2049 * Look up the cheapest existing path with no more than the needed
2050 * parameterization. If it has exactly the needed parameterization, we're
2051 * done.
2052 */
2054 NIL,
2055 required_outer,
2056 TOTAL_COST,
2057 false);
2058 Assert(cheapest != NULL);
2060 return cheapest;
2061
2062 /*
2063 * Otherwise, we can "reparameterize" an existing path to match the given
2064 * parameterization, which effectively means pushing down additional
2065 * joinquals to be checked within the path's scan. However, some existing
2066 * paths might check the available joinquals already while others don't;
2067 * therefore, it's not clear which existing path will be cheapest after
2068 * reparameterization. We have to go through them all and find out.
2069 */
2070 cheapest = NULL;
2072 {
2074
2075 /* Can't use it if it needs more than requested parameterization */
2077 continue;
2078
2079 /*
2080 * Reparameterization can only increase the path's cost, so if it's
2081 * already more expensive than the current cheapest, forget it.
2082 */
2083 if (cheapest != NULL &&
2085 continue;
2086
2087 /* Reparameterize if needed, then recheck cost */
2089 {
2091 if (path == NULL)
2092 continue; /* failed to reparameterize this one */
2094
2095 if (cheapest != NULL &&
2097 continue;
2098 }
2099
2100 /* We have a new best path */
2101 cheapest = path;
2102 }
2103
2104 /* Return the best path, or NULL if we found no suitable candidate */
2105 return cheapest;
2106}
int compare_path_costs(Path *path1, Path *path2, CostSelector criterion)
Definition: pathnode.c:69
Path * reparameterize_path(PlannerInfo *root, Path *path, Relids required_outer, double loop_count)
Definition: pathnode.c:4106
References Assert(), bms_equal(), bms_is_subset(), compare_path_costs(), 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 2175 of file allpaths.c.
2176{
2178
2180 {
2182
2185 }
2187 {
2189
2192 }
2193
2194 return path;
2195}
References Assert(), IsA, linitial, list_length(), Path::parallel_aware, AppendPath::subpaths, and MergeAppendPath::subpaths.
Referenced by generate_orderedappend_paths().
◆ get_useful_pathkeys_for_relation()
|
static |
Definition at line 3162 of file allpaths.c.
3164{
3166
3167 /*
3168 * Considering query_pathkeys is always worth it, because it might allow
3169 * us to avoid a total sort when we have a partially presorted path
3170 * available or to push the total sort into the parallel portion of the
3171 * query.
3172 */
3174 {
3175 ListCell *lc;
3176 int npathkeys = 0; /* useful pathkeys */
3177
3179 {
3181 EquivalenceClass *pathkey_ec = pathkey->pk_eclass;
3182
3183 /*
3184 * We can only build a sort for pathkeys that contain a
3185 * safe-to-compute-early EC member computable from the current
3186 * relation's reltarget, so ignore the remainder of the list as
3187 * soon as we find a pathkey without such a member.
3188 *
3189 * It's still worthwhile to return any prefix of the pathkeys list
3190 * that meets this requirement, as we may be able to do an
3191 * incremental sort.
3192 *
3193 * If requested, ensure the sort expression is parallel-safe too.
3194 */
3196 require_parallel_safe))
3197 break;
3198
3199 npathkeys++;
3200 }
3201
3202 /*
3203 * The whole query_pathkeys list matches, so append it directly, to
3204 * allow comparing pathkeys easily by comparing list pointer. If we
3205 * have to truncate the pathkeys, we gotta do a copy though.
3206 */
3208 useful_pathkeys_list = lappend(useful_pathkeys_list,
3209 root->query_pathkeys);
3210 else if (npathkeys > 0)
3211 useful_pathkeys_list = lappend(useful_pathkeys_list,
3213 npathkeys));
3214 }
3215
3216 return useful_pathkeys_list;
3217}
bool relation_can_be_sorted_early(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, bool require_parallel_safe)
Definition: equivclass.c:1077
Definition: pathnodes.h:1442
Definition: pathnodes.h:1595
References 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 171 of file allpaths.c.
172{
173 RelOptInfo *rel;
174 Index rti;
175 double total_pages;
176
177 /* Mark base rels as to whether we care about fast-start plans */
179
180 /*
181 * Compute size estimates and consider_parallel flags for each base rel.
182 */
184
185 /*
186 * We should now have size estimates for every actual table involved in
187 * the query, and we also know which if any have been deleted from the
188 * query by join removal, pruned by partition pruning, or eliminated by
189 * constraint exclusion. So we can now compute total_table_pages.
190 *
191 * Note that appendrels are not double-counted here, even though we don't
192 * bother to distinguish RelOptInfos for appendrel parents, because the
193 * parents will have pages = 0.
194 *
195 * XXX if a table is self-joined, we will count it once per appearance,
196 * which perhaps is the wrong thing ... but that's not completely clear,
197 * and detecting self-joins here is difficult, so ignore it for now.
198 */
199 total_pages = 0;
201 {
203
204 /* there may be empty slots corresponding to non-baserel RTEs */
205 if (brel == NULL)
206 continue;
207
209
211 continue;
212
214 total_pages += (double) brel->pages;
215 }
216 root->total_table_pages = total_pages;
217
218 /*
219 * Generate access paths for each base rel.
220 */
222
223 /*
224 * Generate access paths for the entire join tree.
225 */
227
228 /*
229 * The result should join all and only the query's base + outer-join rels.
230 */
232
233 return rel;
234}
static void set_base_rel_consider_startup(PlannerInfo *root)
Definition: allpaths.c:247
static void set_base_rel_pathlists(PlannerInfo *root)
Definition: allpaths.c:333
static RelOptInfo * make_rel_from_joinlist(PlannerInfo *root, List *joinlist)
Definition: allpaths.c:3346
References Assert(), bms_equal(), IS_DUMMY_REL, IS_SIMPLE_REL, make_rel_from_joinlist(), RelOptInfo::pages, RelOptInfo::relid, RelOptInfo::relids, root, set_base_rel_consider_startup(), set_base_rel_pathlists(), and set_base_rel_sizes().
Referenced by query_planner().
◆ make_rel_from_joinlist()
|
static |
Definition at line 3346 of file allpaths.c.
3347{
3348 int levels_needed;
3349 List *initial_rels;
3350 ListCell *jl;
3351
3352 /*
3353 * Count the number of child joinlist nodes. This is the depth of the
3354 * dynamic-programming algorithm we must employ to consider all ways of
3355 * joining the child nodes.
3356 */
3357 levels_needed = list_length(joinlist);
3358
3359 if (levels_needed <= 0)
3360 return NULL; /* nothing to do? */
3361
3362 /*
3363 * Construct a list of rels corresponding to the child joinlist nodes.
3364 * This may contain both base rels and rels constructed according to
3365 * sub-joinlists.
3366 */
3367 initial_rels = NIL;
3368 foreach(jl, joinlist)
3369 {
3371 RelOptInfo *thisrel;
3372
3374 {
3376
3378 }
3380 {
3381 /* Recurse to handle subproblem */
3383 }
3384 else
3385 {
3388 thisrel = NULL; /* keep compiler quiet */
3389 }
3390
3391 initial_rels = lappend(initial_rels, thisrel);
3392 }
3393
3394 if (levels_needed == 1)
3395 {
3396 /*
3397 * Single joinlist node, so we're done.
3398 */
3400 }
3401 else
3402 {
3403 /*
3404 * Consider the different orders in which we could join the rels,
3405 * using a plugin, GEQO, or the regular join search code.
3406 *
3407 * We put the initial_rels list into a PlannerInfo field because
3408 * has_legal_joinclause() needs to look at it (ugly :-().
3409 */
3410 root->initial_rels = initial_rels;
3411
3416 else
3418 }
3419}
RelOptInfo * standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
Definition: allpaths.c:3451
RelOptInfo * geqo(PlannerInfo *root, int number_of_rels, List *initial_rels)
Definition: geqo_main.c:72
Definition: primnodes.h:2273
References elog, enable_geqo, ERROR, 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 3895 of file allpaths.c.
3897{
3901 ListCell *vl;
3902
3903 /* Refuse subselects (point 1) */
3906
3907 /* Refuse volatile quals if we found they'd be unsafe (point 2) */
3911
3912 /* Refuse leaky quals if told to (point 3) */
3914 contain_leaked_vars(qual))
3916
3917 /*
3918 * Examine all Vars used in clause. Since it's a restriction clause, all
3919 * such Vars must refer to subselect output columns ... unless this is
3920 * part of a LATERAL subquery, in which case there could be lateral
3921 * references.
3922 *
3923 * By omitting the relevant flags, this also gives us a cheap sanity check
3924 * that no aggregates or window functions appear in the qual. Those would
3925 * be unsafe to push down, but at least for the moment we could never see
3926 * any in a qual anyhow.
3927 */
3930 {
3932
3933 /*
3934 * XXX Punt if we find any PlaceHolderVars in the restriction clause.
3935 * It's not clear whether a PHV could safely be pushed down, and even
3936 * less clear whether such a situation could arise in any cases of
3937 * practical interest anyway. So for the moment, just refuse to push
3938 * down.
3939 */
3941 {
3942 safe = PUSHDOWN_UNSAFE;
3943 break;
3944 }
3945
3946 /*
3947 * Punt if we find any lateral references. It would be safe to push
3948 * these down, but we'd have to convert them into outer references,
3949 * which subquery_push_qual lacks the infrastructure to do. The case
3950 * arises so seldom that it doesn't seem worth working hard on.
3951 */
3953 {
3954 safe = PUSHDOWN_UNSAFE;
3955 break;
3956 }
3957
3958 /* Subqueries have no system columns */
3960
3961 /* Check point 4 */
3963 {
3964 safe = PUSHDOWN_UNSAFE;
3965 break;
3966 }
3967
3968 /* Check point 5 */
3970 {
3974 {
3975 safe = PUSHDOWN_UNSAFE;
3976 break;
3977 }
3978 else
3979 {
3980 /* UNSAFE_NOTIN_PARTITIONBY_CLAUSE is ok for run conditions */
3981 safe = PUSHDOWN_WINDOWCLAUSE_RUNCOND;
3982 /* don't break, we might find another Var that's unsafe */
3983 }
3984 }
3985 }
3986
3988
3989 return safe;
3990}
Definition: regcomp.c:282
References Assert(), RestrictInfo::clause, contain_leaked_vars(), contain_subplans(), contain_volatile_functions(), if(), 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, pushdown_safety_info::unsafeFlags, pushdown_safety_info::unsafeLeaky, pushdown_safety_info::unsafeVolatile, Var::varattno, and Var::varno.
Referenced by set_subquery_pathlist().
◆ recurse_push_qual()
|
static |
Definition at line 4044 of file allpaths.c.
4046{
4048 {
4052
4053 Assert(subquery != NULL);
4054 subquery_push_qual(subquery, rte, rti, qual);
4055 }
4057 {
4059
4062 }
4063 else
4064 {
4067 }
4068}
static void subquery_push_qual(Query *subquery, RangeTblEntry *rte, Index rti, Node *qual)
Definition: allpaths.c:3996
static void recurse_push_qual(Node *setOp, Query *topquery, RangeTblEntry *rte, Index rti, Node *qual)
Definition: allpaths.c:4044
Definition: parsenodes.h:118
Definition: parsenodes.h:1041
Definition: parsenodes.h:2245
References Assert(), elog, ERROR, IsA, SetOperationStmt::larg, nodeTag, SetOperationStmt::rarg, recurse_push_qual(), rt_fetch, Query::rtable, RangeTblRef::rtindex, RangeTblEntry::subquery, and subquery_push_qual().
Referenced by recurse_push_qual(), and subquery_push_qual().
◆ recurse_pushdown_safe()
|
static |
Definition at line 3678 of file allpaths.c.
3680{
3682 {
3686
3687 Assert(subquery != NULL);
3689 }
3691 {
3693
3694 /* EXCEPT is no good (point 2 for subquery_is_pushdown_safe) */
3696 return false;
3697 /* Else recurse */
3699 return false;
3701 return false;
3702 }
3703 else
3704 {
3707 }
3708 return true;
3709}
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3622
static bool recurse_pushdown_safe(Node *setOp, Query *topquery, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3678
References Assert(), elog, ERROR, IsA, SetOperationStmt::larg, nodeTag, SetOperationStmt::op, SetOperationStmt::rarg, recurse_pushdown_safe(), rt_fetch, Query::rtable, RangeTblRef::rtindex, SETOP_EXCEPT, RangeTblEntry::subquery, and subquery_is_pushdown_safe().
Referenced by recurse_pushdown_safe(), and subquery_is_pushdown_safe().
◆ remove_unused_subquery_outputs()
|
static |
Definition at line 4096 of file allpaths.c.
4098{
4099 Bitmapset *attrs_used;
4100 ListCell *lc;
4101
4102 /*
4103 * Just point directly to extra_used_attrs. No need to bms_copy as none of
4104 * the current callers use the Bitmapset after calling this function.
4105 */
4106 attrs_used = extra_used_attrs;
4107
4108 /*
4109 * Do nothing if subquery has UNION/INTERSECT/EXCEPT: in principle we
4110 * could update all the child SELECTs' tlists, but it seems not worth the
4111 * trouble presently.
4112 */
4114 return;
4115
4116 /*
4117 * If subquery has regular DISTINCT (not DISTINCT ON), we're wasting our
4118 * time: all its output columns must be used in the distinctClause.
4119 */
4121 return;
4122
4123 /*
4124 * Collect a bitmap of all the output column numbers used by the upper
4125 * query.
4126 *
4127 * Add all the attributes needed for joins or final output. Note: we must
4128 * look at rel's targetlist, not the attr_needed data, because attr_needed
4129 * isn't computed for inheritance child rels, cf set_append_rel_size().
4130 * (XXX might be worth changing that sometime.)
4131 */
4133
4134 /* Add all the attributes used by un-pushed-down restriction clauses. */
4136 {
4138
4140 }
4141
4142 /*
4143 * If there's a whole-row reference to the subquery, we can't remove
4144 * anything.
4145 */
4147 return;
4148
4149 /*
4150 * Run through the tlist and zap entries we don't need. It's okay to
4151 * modify the tlist items in-place because set_subquery_pathlist made a
4152 * copy of the subquery.
4153 */
4155 {
4158
4159 /*
4160 * If it has a sortgroupref number, it's used in some sort/group
4161 * clause so we'd better not remove it. Also, don't remove any
4162 * resjunk columns, since their reason for being has nothing to do
4163 * with anybody reading the subquery's output. (It's likely that
4164 * resjunk columns in a sub-SELECT would always have ressortgroupref
4165 * set, but even if they don't, it seems imprudent to remove them.)
4166 */
4168 continue;
4169
4170 /*
4171 * If it's used by the upper query, we can't remove it.
4172 */
4174 attrs_used))
4175 continue;
4176
4177 /*
4178 * If it contains a set-returning function, we can't remove it since
4179 * that could change the number of rows returned by the subquery.
4180 */
4181 if (subquery->hasTargetSRFs &&
4182 expression_returns_set(texpr))
4183 continue;
4184
4185 /*
4186 * If it contains volatile functions, we daren't remove it for fear
4187 * that the user is expecting their side-effects to happen.
4188 */
4190 continue;
4191
4192 /*
4193 * OK, we don't need it. Replace the expression with a NULL constant.
4194 * Preserve the exposed type of the expression, in case something
4195 * looks at the rowtype of the subquery's result.
4196 */
4198 exprTypmod(texpr),
4199 exprCollation(texpr));
4200 }
4201}
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition: makefuncs.c:388
Definition: pathnodes.h:2699
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, TargetEntry::expr, exprCollation(), expression_returns_set(), PathTarget::exprs, exprType(), exprTypmod(), FirstLowInvalidHeapAttributeNumber, if(), lfirst, makeNullConst(), pull_varattnos(), RelOptInfo::relid, RelOptInfo::reltarget, TargetEntry::resno, TargetEntry::ressortgroupref, Query::setOperations, and Query::targetList.
Referenced by set_subquery_pathlist().
◆ set_append_rel_pathlist()
|
static |
Definition at line 1251 of file allpaths.c.
1253{
1254 int parentRTindex = rti;
1256 ListCell *l;
1257
1258 /*
1259 * Generate access paths for each member relation, and remember the
1260 * non-dummy children.
1261 */
1263 {
1265 int childRTindex;
1266 RangeTblEntry *childRTE;
1267 RelOptInfo *childrel;
1268
1269 /* append_rel_list contains all append rels; ignore others */
1271 continue;
1272
1273 /* Re-locate the child RTE and RelOptInfo */
1274 childRTindex = appinfo->child_relid;
1275 childRTE = root->simple_rte_array[childRTindex];
1276 childrel = root->simple_rel_array[childRTindex];
1277
1278 /*
1279 * If set_append_rel_size() decided the parent appendrel was
1280 * parallel-unsafe at some point after visiting this child rel, we
1281 * need to propagate the unsafety marking down to the child, so that
1282 * we don't generate useless partial paths for it.
1283 */
1286
1287 /*
1288 * Compute the child's access paths.
1289 */
1291
1292 /*
1293 * If child is dummy, ignore it.
1294 */
1296 continue;
1297
1298 /*
1299 * Child is live, so add it to the live_childrels list for use below.
1300 */
1301 live_childrels = lappend(live_childrels, childrel);
1302 }
1303
1304 /* Add paths to the append relation. */
1306}
static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:469
Definition: pathnodes.h:3099
References add_paths_to_append_rel(), AppendRelInfo::child_relid, RelOptInfo::consider_parallel, IS_DUMMY_REL, lappend(), lfirst, NIL, AppendRelInfo::parent_relid, root, and set_rel_pathlist().
Referenced by set_rel_pathlist().
◆ set_append_rel_size()
|
static |
Definition at line 956 of file allpaths.c.
958{
959 int parentRTindex = rti;
960 bool has_live_children;
961 double parent_tuples;
962 double parent_rows;
963 double parent_size;
964 double *parent_attrsizes;
965 int nattrs;
966 ListCell *l;
967
968 /* Guard against stack overflow due to overly deep inheritance tree. */
969 check_stack_depth();
970
972
973 /*
974 * If this is a partitioned baserel, set the consider_partitionwise_join
975 * flag; currently, we only consider partitionwise joins with the baserel
976 * if its targetlist doesn't contain a whole-row Var.
977 */
980 rte->relkind == RELKIND_PARTITIONED_TABLE &&
983
984 /*
985 * Initialize to compute size estimates for whole append relation.
986 *
987 * We handle tuples estimates by setting "tuples" to the total number of
988 * tuples accumulated from each live child, rather than using "rows".
989 * Although an appendrel itself doesn't directly enforce any quals, its
990 * child relations may. Therefore, setting "tuples" equal to "rows" for
991 * an appendrel isn't always appropriate, and can lead to inaccurate cost
992 * estimates. For example, when estimating the number of distinct values
993 * from an appendrel, we would be unable to adjust the estimate based on
994 * the restriction selectivity (see estimate_num_groups).
995 *
996 * We handle width estimates by weighting the widths of different child
997 * rels proportionally to their number of rows. This is sensible because
998 * the use of width estimates is mainly to compute the total relation
999 * "footprint" if we have to sort or hash it. To do this, we sum the
1000 * total equivalent size (in "double" arithmetic) and then divide by the
1001 * total rowcount estimate. This is done separately for the total rel
1002 * width and each attribute.
1003 *
1004 * Note: if you consider changing this logic, beware that child rels could
1005 * have zero rows and/or width, if they were excluded by constraints.
1006 */
1007 has_live_children = false;
1008 parent_tuples = 0;
1009 parent_rows = 0;
1010 parent_size = 0;
1013
1015 {
1017 int childRTindex;
1018 RangeTblEntry *childRTE;
1019 RelOptInfo *childrel;
1020 List *childrinfos;
1021 ListCell *parentvars;
1022 ListCell *childvars;
1023 ListCell *lc;
1024
1025 /* append_rel_list contains all append rels; ignore others */
1027 continue;
1028
1029 childRTindex = appinfo->child_relid;
1030 childRTE = root->simple_rte_array[childRTindex];
1031
1032 /*
1033 * The child rel's RelOptInfo was already created during
1034 * add_other_rels_to_query.
1035 */
1038
1039 /* We may have already proven the child to be dummy. */
1041 continue;
1042
1043 /*
1044 * We have to copy the parent's targetlist and quals to the child,
1045 * with appropriate substitution of variables. However, the
1046 * baserestrictinfo quals were already copied/substituted when the
1047 * child RelOptInfo was built. So we don't need any additional setup
1048 * before applying constraint exclusion.
1049 */
1051 {
1052 /*
1053 * This child need not be scanned, so we can omit it from the
1054 * appendrel.
1055 */
1056 set_dummy_rel_pathlist(childrel);
1057 continue;
1058 }
1059
1060 /*
1061 * Constraint exclusion failed, so copy the parent's join quals and
1062 * targetlist to the child, with appropriate variable substitutions.
1063 *
1064 * We skip join quals that came from above outer joins that can null
1065 * this rel, since they would be of no value while generating paths
1066 * for the child. This saves some effort while processing the child
1067 * rel, and it also avoids an implementation restriction in
1068 * adjust_appendrel_attrs (it can't apply nullingrels to a non-Var).
1069 */
1070 childrinfos = NIL;
1072 {
1074
1076 childrinfos = lappend(childrinfos,
1078 (Node *) rinfo,
1079 1, &appinfo));
1080 }
1081 childrel->joininfo = childrinfos;
1082
1083 /*
1084 * Now for the child's targetlist.
1085 *
1086 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
1087 * expressions, which otherwise would not occur in a rel's targetlist.
1088 * Code that might be looking at an appendrel child must cope with
1089 * such. (Normally, a rel's targetlist would only include Vars and
1090 * PlaceHolderVars.) XXX we do not bother to update the cost or width
1091 * fields of childrel->reltarget; not clear if that would be useful.
1092 */
1096 1, &appinfo);
1097
1098 /*
1099 * We have to make child entries in the EquivalenceClass data
1100 * structures as well. This is needed either if the parent
1101 * participates in some eclass joins (because we will want to consider
1102 * inner-indexscan joins on the individual children) or if the parent
1103 * has useful pathkeys (because we should try to build MergeAppend
1104 * paths that produce those sort orderings).
1105 */
1109
1110 /*
1111 * Note: we could compute appropriate attr_needed data for the child's
1112 * variables, by transforming the parent's attr_needed through the
1113 * translated_vars mapping. However, currently there's no need
1114 * because attr_needed is only examined for base relations not
1115 * otherrels. So we just leave the child's attr_needed empty.
1116 */
1117
1118 /*
1119 * If we consider partitionwise joins with the parent rel, do the same
1120 * for partitioned child rels.
1121 *
1122 * Note: here we abuse the consider_partitionwise_join flag by setting
1123 * it for child rels that are not themselves partitioned. We do so to
1124 * tell try_partitionwise_join() that the child rel is sufficiently
1125 * valid to be used as a per-partition input, even if it later gets
1126 * proven to be dummy. (It's not usable until we've set up the
1127 * reltarget and EC entries, which we just did.)
1128 */
1131
1132 /*
1133 * If parallelism is allowable for this query in general, see whether
1134 * it's allowable for this childrel in particular. But if we've
1135 * already decided the appendrel is not parallel-safe as a whole,
1136 * there's no point in considering parallelism for this child. For
1137 * consistency, do this before calling set_rel_size() for the child.
1138 */
1141
1142 /*
1143 * Compute the child's size.
1144 */
1146
1147 /*
1148 * It is possible that constraint exclusion detected a contradiction
1149 * within a child subquery, even though we didn't prove one above. If
1150 * so, we can skip this child.
1151 */
1153 continue;
1154
1155 /* We have at least one live child. */
1156 has_live_children = true;
1157
1158 /*
1159 * If any live child is not parallel-safe, treat the whole appendrel
1160 * as not parallel-safe. In future we might be able to generate plans
1161 * in which some children are farmed out to workers while others are
1162 * not; but we don't have that today, so it's a waste to consider
1163 * partial paths anywhere in the appendrel unless it's all safe.
1164 * (Child rels visited before this one will be unmarked in
1165 * set_append_rel_pathlist().)
1166 */
1169
1170 /*
1171 * Accumulate size information from each live child.
1172 */
1174
1175 parent_tuples += childrel->tuples;
1176 parent_rows += childrel->rows;
1178
1179 /*
1180 * Accumulate per-column estimates too. We need not do anything for
1181 * PlaceHolderVars in the parent list. If child expression isn't a
1182 * Var, or we didn't record a width estimate for it, we have to fall
1183 * back on a datatype-based estimate.
1184 *
1185 * By construction, child's targetlist is 1-to-1 with parent's.
1186 */
1189 {
1192
1194 {
1196 int32 child_width = 0;
1197
1200 {
1202
1203 child_width = childrel->attr_widths[cndx];
1204 }
1205 if (child_width <= 0)
1207 exprTypmod(childvar));
1208 Assert(child_width > 0);
1209 parent_attrsizes[pndx] += child_width * childrel->rows;
1210 }
1211 }
1212 }
1213
1214 if (has_live_children)
1215 {
1216 /*
1217 * Save the finished size estimates.
1218 */
1220
1221 Assert(parent_rows > 0);
1222 rel->tuples = parent_tuples;
1223 rel->rows = parent_rows;
1227
1228 /*
1229 * Note that we leave rel->pages as zero; this is important to avoid
1230 * double-counting the appendrel tree in total_table_pages.
1231 */
1232 }
1233 else
1234 {
1235 /*
1236 * All children were excluded by constraints, so mark the whole
1237 * appendrel dummy. We must do this in this phase so that the rel's
1238 * dummy-ness is visible when we generate paths for other rels.
1239 */
1240 set_dummy_rel_pathlist(rel);
1241 }
1242
1243 pfree(parent_attrsizes);
1244}
static void set_dummy_rel_pathlist(RelOptInfo *rel)
Definition: allpaths.c:2209
static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:589
static void set_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:360
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:2833
bool has_useful_pathkeys(PlannerInfo *root, RelOptInfo *rel)
Definition: pathkeys.c:2319
bool relation_excluded_by_constraints(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: plancat.c:1596
References add_child_rel_equivalences(), adjust_appendrel_attrs(), Assert(), bms_is_empty, bms_overlap(), check_stack_depth(), AppendRelInfo::child_relid, RelOptInfo::consider_parallel, RelOptInfo::consider_partitionwise_join, enable_partitionwise_join, PathTarget::exprs, exprType(), exprTypmod(), 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(), AppendRelInfo::parent_relid, pfree(), relation_excluded_by_constraints(), RelOptInfo::relid, 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, Var::varattno, Var::varno, and PathTarget::width.
Referenced by set_rel_size().
◆ set_base_rel_consider_startup()
|
static |
Definition at line 247 of file allpaths.c.
248{
249 /*
250 * Since parameterized paths can only be used on the inside of a nestloop
251 * join plan, there is usually little value in considering fast-start
252 * plans for them. However, for relations that are on the RHS of a SEMI
253 * or ANTI join, a fast-start plan can be useful because we're only going
254 * to care about fetching one tuple anyway.
255 *
256 * To minimize growth of planning time, we currently restrict this to
257 * cases where the RHS is a single base relation, not a join; there is no
258 * provision for consider_param_startup to get set at all on joinrels.
259 * Also we don't worry about appendrels. costsize.c's costing rules for
260 * nestloop semi/antijoins don't consider such cases either.
261 */
262 ListCell *lc;
263
265 {
267 int varno;
268
271 {
273
275 }
276 }
277}
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition: bitmapset.c:715
Definition: pathnodes.h:3031
References bms_get_singleton_member(), RelOptInfo::consider_param_startup, 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 333 of file allpaths.c.
334{
335 Index rti;
336
338 {
340
341 /* there may be empty slots corresponding to non-baserel RTEs */
342 if (rel == NULL)
343 continue;
344
346
347 /* ignore RTEs that are "other rels" */
349 continue;
350
352 }
353}
References Assert(), RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, root, and set_rel_pathlist().
Referenced by make_one_rel().
◆ set_base_rel_sizes()
|
static |
Definition at line 290 of file allpaths.c.
291{
292 Index rti;
293
295 {
297 RangeTblEntry *rte;
298
299 /* there may be empty slots corresponding to non-baserel RTEs */
300 if (rel == NULL)
301 continue;
302
304
305 /* ignore RTEs that are "other rels" */
307 continue;
308
309 rte = root->simple_rte_array[rti];
310
311 /*
312 * If parallelism is allowable for this query in general, see whether
313 * it's allowable for this rel in particular. We have to do this
314 * before set_rel_size(), because (a) if this rel is an inheritance
315 * parent, set_append_rel_size() will use and perhaps change the rel's
316 * consider_parallel flag, and (b) for some RTE types, set_rel_size()
317 * goes ahead and makes paths immediately.
318 */
321
323 }
324}
References Assert(), 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 2901 of file allpaths.c.
2902{
2903 Path *ctepath;
2904 Plan *cteplan;
2905 PlannerInfo *cteroot;
2906 Index levelsup;
2907 List *pathkeys;
2908 int ndx;
2909 ListCell *lc;
2910 int plan_id;
2911 Relids required_outer;
2912
2913 /*
2914 * Find the referenced CTE, and locate the path and plan previously made
2915 * for it.
2916 */
2917 levelsup = rte->ctelevelsup;
2918 cteroot = root;
2919 while (levelsup-- > 0)
2920 {
2921 cteroot = cteroot->parent_root;
2922 if (!cteroot) /* shouldn't happen */
2924 }
2925
2926 /*
2927 * Note: cte_plan_ids can be shorter than cteList, if we are still working
2928 * on planning the CTEs (ie, this is a side-reference from another CTE).
2929 * So we mustn't use forboth here.
2930 */
2931 ndx = 0;
2933 {
2935
2937 break;
2938 ndx++;
2939 }
2940 if (lc == NULL) /* shouldn't happen */
2945 if (plan_id <= 0)
2947
2951
2952 /* Mark rel with estimated output rows, width, etc */
2954
2955 /* Convert the ctepath's pathkeys to outer query's representation */
2957 rel,
2958 ctepath->pathkeys,
2959 cteplan->targetlist);
2960
2961 /*
2962 * We don't support pushing join clauses into the quals of a CTE scan, but
2963 * it could still have required parameterization due to LATERAL refs in
2964 * its tlist.
2965 */
2966 required_outer = rel->lateral_relids;
2967
2968 /* Generate appropriate path */
2970}
void set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel, double cte_rows)
Definition: costsize.c:6061
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:2196
Definition: parsenodes.h:1683
Definition: plannodes.h:159
Definition: pathnodes.h:217
References add_path(), Assert(), convert_subquery_pathkeys(), create_ctescan_path(), PlannerInfo::cte_plan_ids, RangeTblEntry::ctelevelsup, Query::cteList, RangeTblEntry::ctename, CommonTableExpr::ctename, elog, ERROR, RelOptInfo::lateral_relids, lfirst, list_length(), list_nth(), list_nth_int(), PlannerInfo::parse, Path::pathkeys, Plan::plan_rows, root, set_cte_size_estimates(), and Plan::targetlist.
Referenced by set_rel_size().
◆ set_dummy_rel_pathlist()
|
static |
Definition at line 2209 of file allpaths.c.
2210{
2211 /* Set dummy size estimates --- we leave attr_widths[] as zeroes */
2212 rel->rows = 0;
2214
2215 /* Discard any pre-existing paths; no further need for them */
2218
2219 /* Set up the dummy path */
2222 0, false, -1));
2223
2224 /*
2225 * We set the cheapest-path fields immediately, just in case they were
2226 * pointing at some discarded path. This is redundant in current usage
2227 * because set_rel_pathlist will do it later, but it's cheap so we keep it
2228 * for safety and consistency with mark_dummy_rel.
2229 */
2230 set_cheapest(rel);
2231}
References add_path(), create_append_path(), 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 938 of file allpaths.c.
939{
940 /* Call the FDW's GetForeignPaths function to generate path(s) */
941 rel->fdwroutine->GetForeignPaths(root, rel, rte->relid);
942}
References root.
Referenced by set_rel_pathlist().
◆ set_foreign_size()
|
static |
Definition at line 914 of file allpaths.c.
915{
916 /* Mark rel with estimated output rows, width, etc */
918
919 /* Let FDW adjust the size estimates, if it can */
920 rel->fdwroutine->GetForeignRelSize(root, rel, rte->relid);
921
922 /* ... but do not let it set the rows estimate to zero */
924
925 /*
926 * Also, make sure rel->tuples is not insane relative to rel->rows.
927 * Notably, this ensures sanity if pg_class.reltuples contains -1 and the
928 * FDW doesn't do anything to replace that.
929 */
931}
void set_foreign_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6161
References clamp_row_est(), Max, root, RelOptInfo::rows, set_foreign_size_estimates(), and RelOptInfo::tuples.
Referenced by set_rel_size().
◆ set_function_pathlist()
|
static |
Definition at line 2790 of file allpaths.c.
2791{
2792 Relids required_outer;
2794
2795 /*
2796 * We don't support pushing join clauses into the quals of a function
2797 * scan, but it could still have required parameterization due to LATERAL
2798 * refs in the function expression.
2799 */
2800 required_outer = rel->lateral_relids;
2801
2802 /*
2803 * The result is considered unordered unless ORDINALITY was used, in which
2804 * case it is ordered by the ordinal column (the last one). See if we
2805 * care, by checking for uses of that Var in equivalence classes.
2806 */
2808 {
2810 Var *var = NULL;
2811 ListCell *lc;
2812
2813 /*
2814 * Is there a Var for it in rel's targetlist? If not, the query did
2815 * not reference the ordinality column, or at least not in any way
2816 * that would be interesting for sorting.
2817 */
2819 {
2821
2822 /* checking varno/varlevelsup is just paranoia */
2824 node->varattno == ordattno &&
2826 node->varlevelsup == 0)
2827 {
2828 var = node;
2829 break;
2830 }
2831 }
2832
2833 /*
2834 * Try to build pathkeys for this Var with int8 sorting. We tell
2835 * build_expression_pathkey not to build any new equivalence class; if
2836 * the Var isn't already mentioned in some EC, it means that nothing
2837 * cares about the ordering.
2838 */
2839 if (var)
2841 (Expr *) var,
2842 Int8LessOperator,
2843 rel->relids,
2844 false);
2845 }
2846
2847 /* Generate appropriate path */
2849 pathkeys, required_outer));
2850}
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:2118
References add_path(), build_expression_pathkey(), create_functionscan_path(), PathTarget::exprs, RangeTblEntry::funcordinality, 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_namedtuplestore_pathlist()
|
static |
Definition at line 2980 of file allpaths.c.
2982{
2983 Relids required_outer;
2984
2985 /* Mark rel with estimated output rows, width, etc */
2987
2988 /*
2989 * We don't support pushing join clauses into the quals of a tuplestore
2990 * scan, but it could still have required parameterization due to LATERAL
2991 * refs in its tlist.
2992 */
2993 required_outer = rel->lateral_relids;
2994
2995 /* Generate appropriate path */
2997}
void set_namedtuplestore_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6099
Path * create_namedtuplestorescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2222
References add_path(), create_namedtuplestorescan_path(), RelOptInfo::lateral_relids, root, and set_namedtuplestore_size_estimates().
Referenced by set_rel_size().
◆ set_plain_rel_pathlist()
|
static |
Definition at line 768 of file allpaths.c.
769{
770 Relids required_outer;
771
772 /*
773 * We don't support pushing join clauses into the quals of a seqscan, but
774 * it could still have required parameterization due to LATERAL refs in
775 * its tlist.
776 */
777 required_outer = rel->lateral_relids;
778
779 /*
780 * Consider TID scans.
781 *
782 * If create_tidscan_paths returns true, then a TID scan path is forced.
783 * This happens when rel->baserestrictinfo contains CurrentOfExpr, because
784 * the executor can't handle any other type of path for such queries.
785 * Hence, we return without adding any other paths.
786 */
788 return;
789
790 /* Consider sequential scan */
792
793 /* If appropriate, consider parallel sequential scan */
796
797 /* Consider index scans */
799}
static void create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: allpaths.c:806
void create_index_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: indxpath.c:239
bool create_tidscan_paths(PlannerInfo *root, RelOptInfo *rel)
Definition: tidpath.c:498
References add_path(), RelOptInfo::consider_parallel, create_index_paths(), create_plain_partial_paths(), create_seqscan_path(), create_tidscan_paths(), RelOptInfo::lateral_relids, and root.
Referenced by set_rel_pathlist().
◆ set_plain_rel_size()
|
static |
Definition at line 572 of file allpaths.c.
573{
574 /*
575 * Test any partial indexes of rel for applicability. We must do this
576 * first since partial unique indexes can affect size estimates.
577 */
579
580 /* Mark rel with estimated output rows, width, etc */
582}
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:5335
void check_index_predicates(PlannerInfo *root, RelOptInfo *rel)
Definition: indxpath.c:3966
References check_index_predicates(), root, and set_baserel_size_estimates().
Referenced by set_rel_size().
◆ set_rel_consider_parallel()
|
static |
Definition at line 589 of file allpaths.c.
591{
592 /*
593 * The flag has previously been initialized to false, so we can just
594 * return if it becomes clear that we can't safely set it.
595 */
597
598 /* Don't call this if parallelism is disallowed for the entire query. */
600
601 /* This should only be called for baserels and appendrel children. */
603
604 /* Assorted checks based on rtekind. */
606 {
608
609 /*
610 * Currently, parallel workers can't access the leader's temporary
611 * tables. We could possibly relax this if we wrote all of its
612 * local buffers at the start of the query and made no changes
613 * thereafter (maybe we could allow hint bit changes), and if we
614 * taught the workers to read them. Writing a large number of
615 * temporary buffers could be expensive, though, and we don't have
616 * the rest of the necessary infrastructure right now anyway. So
617 * for now, bail out if we see a temporary table.
618 */
620 return;
621
622 /*
623 * Table sampling can be pushed down to workers if the sample
624 * function and its arguments are safe.
625 */
627 {
629
630 if (proparallel != PROPARALLEL_SAFE)
631 return;
633 return;
634 }
635
636 /*
637 * Ask FDWs whether they can support performing a ForeignScan
638 * within a worker. Most often, the answer will be no. For
639 * example, if the nature of the FDW is such that it opens a TCP
640 * connection with a remote server, each parallel worker would end
641 * up with a separate connection, and these connections might not
642 * be appropriately coordinated between workers and the leader.
643 */
644 if (rte->relkind == RELKIND_FOREIGN_TABLE)
645 {
646 Assert(rel->fdwroutine);
647 if (!rel->fdwroutine->IsForeignScanParallelSafe)
648 return;
650 return;
651 }
652
653 /*
654 * There are additional considerations for appendrels, which we'll
655 * deal with in set_append_rel_size and set_append_rel_pathlist.
656 * For now, just set consider_parallel based on the rel's own
657 * quals and targetlist.
658 */
659 break;
660
662
663 /*
664 * There's no intrinsic problem with scanning a subquery-in-FROM
665 * (as distinct from a SubPlan or InitPlan) in a parallel worker.
666 * If the subquery doesn't happen to have any parallel-safe paths,
667 * then flagging it as consider_parallel won't change anything,
668 * but that's true for plain tables, too. We must set
669 * consider_parallel based on the rel's own quals and targetlist,
670 * so that if a subquery path is parallel-safe but the quals and
671 * projection we're sticking onto it are not, we correctly mark
672 * the SubqueryScanPath as not parallel-safe. (Note that
673 * set_subquery_pathlist() might push some of these quals down
674 * into the subquery itself, but that doesn't change anything.)
675 *
676 * We can't push sub-select containing LIMIT/OFFSET to workers as
677 * there is no guarantee that the row order will be fully
678 * deterministic, and applying LIMIT/OFFSET will lead to
679 * inconsistent results at the top-level. (In some cases, where
680 * the result is ordered, we could relax this restriction. But it
681 * doesn't currently seem worth expending extra effort to do so.)
682 */
683 {
685
687 return;
688 }
689 break;
690
692 /* Shouldn't happen; we're only considering baserels here. */
694 return;
695
697 /* Check for parallel-restricted functions. */
699 return;
700 break;
701
703 /* not parallel safe */
704 return;
705
707 /* Check for parallel-restricted functions. */
709 return;
710 break;
711
713
714 /*
715 * CTE tuplestores aren't shared among parallel workers, so we
716 * force all CTE scans to happen in the leader. Also, populating
717 * the CTE would require executing a subplan that's not available
718 * in the worker, might be parallel-restricted, and must get
719 * executed only once.
720 */
721 return;
722
724
725 /*
726 * tuplestore cannot be shared, at least without more
727 * infrastructure to support that.
728 */
729 return;
730
732 /* RESULT RTEs, in themselves, are no problem. */
733 break;
735 /* Shouldn't happen; we're only considering baserels here. */
737 return;
738 }
739
740 /*
741 * If there's anything in baserestrictinfo that's parallel-restricted, we
742 * give up on parallelizing access to this relation. We could consider
743 * instead postponing application of the restricted quals until we're
744 * above all the parallelism in the plan tree, but it's not clear that
745 * that would be a win in very many cases, and it might be tricky to make
746 * outer join clauses work correctly. It would likely break equivalence
747 * classes, too.
748 */
750 return;
751
752 /*
753 * Likewise, if the relation's outputs are not parallel-safe, give up.
754 * (Usually, they're just Vars, but sometimes they're not.)
755 */
757 return;
758
759 /* We have a winner. */
761}
References TableSampleClause::args, Assert(), RelOptInfo::baserestrictinfo, castNode, RelOptInfo::consider_parallel, PathTarget::exprs, func_parallel(), RangeTblEntry::functions, 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, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::subquery, RangeTblEntry::tablesample, TableSampleClause::tsmhandler, and RangeTblEntry::values_lists.
Referenced by set_append_rel_size(), and set_base_rel_sizes().
◆ set_rel_pathlist()
|
static |
Definition at line 469 of file allpaths.c.
471{
473 {
474 /* We already proved the relation empty, so nothing more to do */
475 }
477 {
478 /* It's an "append relation", process accordingly */
480 }
481 else
482 {
484 {
486 if (rte->relkind == RELKIND_FOREIGN_TABLE)
487 {
488 /* Foreign table */
490 }
492 {
493 /* Sampled relation */
495 }
496 else
497 {
498 /* Plain relation */
500 }
501 break;
503 /* Subquery --- fully handled during set_rel_size */
504 break;
506 /* RangeFunction */
508 break;
510 /* Table Function */
512 break;
514 /* Values list */
516 break;
518 /* CTE reference --- fully handled during set_rel_size */
519 break;
521 /* tuplestore reference --- fully handled during set_rel_size */
522 break;
524 /* simple Result --- fully handled during set_rel_size */
525 break;
526 default:
528 break;
529 }
530 }
531
532 /*
533 * Allow a plugin to editorialize on the set of Paths for this base
534 * relation. It could add new paths (such as CustomPaths) by calling
535 * add_path(), or add_partial_path() if parallel aware. It could also
536 * delete or modify paths added by the core code.
537 */
539 (*set_rel_pathlist_hook) (root, rel, rti, rte);
540
541 /*
542 * If this is a baserel, we should normally consider gathering any partial
543 * paths we may have created for it. We have to do this after calling the
544 * set_rel_pathlist_hook, else it cannot add partial paths to be included
545 * here.
546 *
547 * However, if this is an inheritance child, skip it. Otherwise, we could
548 * end up with a very large number of gather nodes, each trying to grab
549 * its own pool of workers. Instead, we'll consider gathering partial
550 * paths for the parent appendrel.
551 *
552 * Also, if this is the topmost scan/join rel, we postpone gathering until
553 * the final scan/join targetlist is available (see grouping_planner).
554 */
558
559 /* Now find the cheapest of the paths for this rel */
560 set_cheapest(rel);
561
562#ifdef OPTIMIZER_DEBUG
563 pprint(rel);
564#endif
565}
static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:866
static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:938
static void set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:1251
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition: allpaths.c:3230
static void set_function_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2790
static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:768
static void set_tablefunc_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2877
static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2857
References bms_equal(), elog, ERROR, generate_useful_gather_paths(), RangeTblEntry::inh, 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_plain_rel_pathlist(), set_rel_pathlist_hook, set_tablefunc_pathlist(), set_tablesample_rel_pathlist(), set_values_pathlist(), and RangeTblEntry::tablesample.
Referenced by set_append_rel_pathlist(), and set_base_rel_pathlists().
◆ set_rel_size()
|
static |
Definition at line 360 of file allpaths.c.
362{
365 {
366 /*
367 * We proved we don't need to scan the rel via constraint exclusion,
368 * so set up a single dummy path for it. Here we only check this for
369 * regular baserels; if it's an otherrel, CE was already checked in
370 * set_append_rel_size().
371 *
372 * In this case, we go ahead and set up the relation's path right away
373 * instead of leaving it for set_rel_pathlist to do. This is because
374 * we don't have a convention for marking a rel as dummy except by
375 * assigning a dummy path to it.
376 */
377 set_dummy_rel_pathlist(rel);
378 }
380 {
381 /* It's an "append relation", process accordingly */
383 }
384 else
385 {
387 {
389 if (rte->relkind == RELKIND_FOREIGN_TABLE)
390 {
391 /* Foreign table */
393 }
394 else if (rte->relkind == RELKIND_PARTITIONED_TABLE)
395 {
396 /*
397 * We could get here if asked to scan a partitioned table
398 * with ONLY. In that case we shouldn't scan any of the
399 * partitions, so mark it as a dummy rel.
400 */
401 set_dummy_rel_pathlist(rel);
402 }
404 {
405 /* Sampled relation */
407 }
408 else
409 {
410 /* Plain relation */
412 }
413 break;
415
416 /*
417 * Subqueries don't support making a choice between
418 * parameterized and unparameterized paths, so just go ahead
419 * and build their paths immediately.
420 */
422 break;
425 break;
428 break;
431 break;
433
434 /*
435 * CTEs don't support making a choice between parameterized
436 * and unparameterized paths, so just go ahead and build their
437 * paths immediately.
438 */
439 if (rte->self_reference)
441 else
443 break;
445 /* Might as well just build the path immediately */
447 break;
449 /* Might as well just build the path immediately */
451 break;
452 default:
454 break;
455 }
456 }
457
458 /*
459 * We insist that all non-dummy rels have a nonzero rowcount estimate.
460 */
462}
static void set_subquery_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:2523
static void set_namedtuplestore_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2980
static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:826
static void set_result_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:3007
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:3034
static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:914
static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:2901
static void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte)
Definition: allpaths.c:956
static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte)
Definition: allpaths.c:572
void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:5969
void set_tablefunc_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6007
void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6029
References Assert(), elog, ERROR, RangeTblEntry::inh, 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(), set_worktable_pathlist(), and RangeTblEntry::tablesample.
Referenced by set_append_rel_size(), and set_base_rel_sizes().
◆ set_result_pathlist()
|
static |
Definition at line 3007 of file allpaths.c.
3009{
3010 Relids required_outer;
3011
3012 /* Mark rel with estimated output rows, width, etc */
3014
3015 /*
3016 * We don't support pushing join clauses into the quals of a Result scan,
3017 * but it could still have required parameterization due to LATERAL refs
3018 * in its tlist.
3019 */
3020 required_outer = rel->lateral_relids;
3021
3022 /* Generate appropriate path */
3024}
void set_result_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:6132
Path * create_resultscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2248
References add_path(), create_resultscan_path(), RelOptInfo::lateral_relids, root, and set_result_size_estimates().
Referenced by set_rel_size().
◆ set_subquery_pathlist()
|
static |
Definition at line 2523 of file allpaths.c.
2525{
2528 bool trivial_pathtarget;
2529 Relids required_outer;
2530 pushdown_safety_info safetyInfo;
2531 double tuple_fraction;
2532 RelOptInfo *sub_final_rel;
2533 Bitmapset *run_cond_attrs = NULL;
2534 ListCell *lc;
2535
2536 /*
2537 * Must copy the Query so that planning doesn't mess up the RTE contents
2538 * (really really need to fix the planner to not scribble on its input,
2539 * someday ... but see remove_unused_subquery_outputs to start with).
2540 */
2541 subquery = copyObject(subquery);
2542
2543 /*
2544 * If it's a LATERAL subquery, it might contain some Vars of the current
2545 * query level, requiring it to be treated as parameterized, even though
2546 * we don't support pushing down join quals into subqueries.
2547 */
2548 required_outer = rel->lateral_relids;
2549
2550 /*
2551 * Zero out result area for subquery_is_pushdown_safe, so that it can set
2552 * flags as needed while recursing. In particular, we need a workspace
2553 * for keeping track of the reasons why columns are unsafe to reference.
2554 * These reasons are stored in the bits inside unsafeFlags[i] when we
2555 * discover reasons that column i of the subquery is unsafe to be used in
2556 * a pushed-down qual.
2557 */
2558 memset(&safetyInfo, 0, sizeof(safetyInfo));
2561
2562 /*
2563 * If the subquery has the "security_barrier" flag, it means the subquery
2564 * originated from a view that must enforce row-level security. Then we
2565 * must not push down quals that contain leaky functions. (Ideally this
2566 * would be checked inside subquery_is_pushdown_safe, but since we don't
2567 * currently pass the RTE to that function, we must do it here.)
2568 */
2569 safetyInfo.unsafeLeaky = rte->security_barrier;
2570
2571 /*
2572 * If there are any restriction clauses that have been attached to the
2573 * subquery relation, consider pushing them down to become WHERE or HAVING
2574 * quals of the subquery itself. This transformation is useful because it
2575 * may allow us to generate a better plan for the subquery than evaluating
2576 * all the subquery output rows and then filtering them.
2577 *
2578 * There are several cases where we cannot push down clauses. Restrictions
2579 * involving the subquery are checked by subquery_is_pushdown_safe().
2580 * Restrictions on individual clauses are checked by
2581 * qual_is_pushdown_safe(). Also, we don't want to push down
2582 * pseudoconstant clauses; better to have the gating node above the
2583 * subquery.
2584 *
2585 * Non-pushed-down clauses will get evaluated as qpquals of the
2586 * SubqueryScan node.
2587 *
2588 * XXX Are there any cases where we want to make a policy decision not to
2589 * push down a pushable qual, because it'd result in a worse plan?
2590 */
2592 subquery_is_pushdown_safe(subquery, subquery, &safetyInfo))
2593 {
2594 /* OK to consider pushing down individual quals */
2596 ListCell *l;
2597
2599 {
2602
2603 if (rinfo->pseudoconstant)
2604 {
2605 upperrestrictlist = lappend(upperrestrictlist, rinfo);
2606 continue;
2607 }
2608
2610 {
2612 /* Push it down */
2613 subquery_push_qual(subquery, rte, rti, clause);
2614 break;
2615
2617
2618 /*
2619 * Since we can't push the qual down into the subquery,
2620 * check if it happens to reference a window function. If
2621 * so then it might be useful to use for the WindowAgg's
2622 * runCondition.
2623 */
2624 if (!subquery->hasWindowFuncs ||
2625 check_and_push_window_quals(subquery, rte, rti, clause,
2626 &run_cond_attrs))
2627 {
2628 /*
2629 * subquery has no window funcs or the clause is not a
2630 * suitable window run condition qual or it is, but
2631 * the original must also be kept in the upper query.
2632 */
2633 upperrestrictlist = lappend(upperrestrictlist, rinfo);
2634 }
2635 break;
2636
2638 upperrestrictlist = lappend(upperrestrictlist, rinfo);
2639 break;
2640 }
2641 }
2642 rel->baserestrictinfo = upperrestrictlist;
2643 /* We don't bother recomputing baserestrict_min_security */
2644 }
2645
2647
2648 /*
2649 * The upper query might not use all the subquery's output columns; if
2650 * not, we can simplify. Pass the attributes that were pushed down into
2651 * WindowAgg run conditions to ensure we don't accidentally think those
2652 * are unused.
2653 */
2654 remove_unused_subquery_outputs(subquery, rel, run_cond_attrs);
2655
2656 /*
2657 * We can safely pass the outer tuple_fraction down to the subquery if the
2658 * outer level has no joining, aggregation, or sorting to do. Otherwise
2659 * we'd better tell the subquery to plan for full retrieval. (XXX This
2660 * could probably be made more intelligent ...)
2661 */
2663 parse->groupClause ||
2664 parse->groupingSets ||
2665 root->hasHavingQual ||
2666 parse->distinctClause ||
2667 parse->sortClause ||
2669 tuple_fraction = 0.0; /* default case */
2670 else
2671 tuple_fraction = root->tuple_fraction;
2672
2673 /* plan_params should not be in use in current query level */
2675
2676 /* Generate a subroot and Paths for the subquery */
2678 tuple_fraction, NULL);
2679
2680 /* Isolate the params needed by this specific subplan */
2683
2684 /*
2685 * It's possible that constraint exclusion proved the subquery empty. If
2686 * so, it's desirable to produce an unadorned dummy path so that we will
2687 * recognize appropriate optimizations at this query level.
2688 */
2690
2692 {
2693 set_dummy_rel_pathlist(rel);
2694 return;
2695 }
2696
2697 /*
2698 * Mark rel with estimated output rows, width, etc. Note that we have to
2699 * do this before generating outer-query paths, else cost_subqueryscan is
2700 * not happy.
2701 */
2703
2704 /*
2705 * Also detect whether the reltarget is trivial, so that we can pass that
2706 * info to cost_subqueryscan (rather than re-deriving it multiple times).
2707 * It's trivial if it fetches all the subplan output columns in order.
2708 */
2710 trivial_pathtarget = false;
2711 else
2712 {
2713 trivial_pathtarget = true;
2715 {
2717 Var *var;
2718
2720 {
2721 trivial_pathtarget = false;
2722 break;
2723 }
2724 var = (Var *) node;
2727 {
2728 trivial_pathtarget = false;
2729 break;
2730 }
2731 }
2732 }
2733
2734 /*
2735 * For each Path that subquery_planner produced, make a SubqueryScanPath
2736 * in the outer query.
2737 */
2739 {
2741 List *pathkeys;
2742
2743 /* Convert subpath's pathkeys to outer representation */
2745 rel,
2746 subpath->pathkeys,
2748
2749 /* Generate outer path using this subpath */
2752 trivial_pathtarget,
2753 pathkeys, required_outer));
2754 }
2755
2756 /* If outer rel allows parallelism, do same for partial paths. */
2758 {
2759 /* If consider_parallel is false, there should be no partial paths. */
2762
2763 /* Same for partial paths. */
2765 {
2767 List *pathkeys;
2768
2769 /* Convert subpath's pathkeys to outer representation */
2771 rel,
2772 subpath->pathkeys,
2774
2775 /* Generate outer path using this subpath */
2778 trivial_pathtarget,
2779 pathkeys,
2780 required_outer));
2781 }
2782 }
2783}
static pushdown_safe_type qual_is_pushdown_safe(Query *subquery, Index rti, RestrictInfo *rinfo, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3895
static bool check_and_push_window_quals(Query *subquery, RangeTblEntry *rte, Index rti, Node *clause, Bitmapset **run_cond_attrs)
Definition: allpaths.c:2448
static void remove_unused_subquery_outputs(Query *subquery, RelOptInfo *rel, Bitmapset *extra_used_attrs)
Definition: allpaths.c:4096
void set_subquery_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition: costsize.c:5889
SubqueryScanPath * create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, bool trivial_pathtarget, List *pathkeys, Relids required_outer)
Definition: pathnode.c:2088
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, PlannerInfo *parent_root, bool hasRecursion, double tuple_fraction, SetOperationStmt *setops)
Definition: planner.c:650
static struct subre * parse(struct vars *v, int stopper, int type, struct state *init, struct state *final)
Definition: regcomp.c:717
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition: relnode.c:1458
Definition: allpaths.c:61
List * make_tlist_from_pathtarget(PathTarget *target)
Definition: tlist.c:624
References add_partial_path(), add_path(), Assert(), RelOptInfo::baserestrictinfo, bms_is_empty, bms_membership(), BMS_MULTIPLE, check_and_push_window_quals(), RestrictInfo::clause, RelOptInfo::consider_parallel, convert_subquery_pathkeys(), copyObject, create_subqueryscan_path(), PathTarget::exprs, fetch_upper_rel(), foreach_current_index, if(), IS_DUMMY_REL, IsA, lappend(), RelOptInfo::lateral_relids, lfirst, list_length(), make_tlist_from_pathtarget(), NIL, palloc0(), parse(), RelOptInfo::partial_pathlist, RelOptInfo::pathlist, 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, RangeTblEntry::subquery, subquery_is_pushdown_safe(), subquery_planner(), subquery_push_qual(), RelOptInfo::subroot, Query::targetList, pushdown_safety_info::unsafeFlags, pushdown_safety_info::unsafeLeaky, UPPERREL_FINAL, Var::varattno, and Var::varno.
Referenced by set_rel_size().
◆ set_tablefunc_pathlist()
|
static |
Definition at line 2877 of file allpaths.c.
2878{
2879 Relids required_outer;
2880
2881 /*
2882 * We don't support pushing join clauses into the quals of a tablefunc
2883 * scan, but it could still have required parameterization due to LATERAL
2884 * refs in the function expression.
2885 */
2886 required_outer = rel->lateral_relids;
2887
2888 /* Generate appropriate path */
2890 required_outer));
2891}
Path * create_tablefuncscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2144
References add_path(), create_tablefuncscan_path(), RelOptInfo::lateral_relids, and root.
Referenced by set_rel_pathlist().
◆ set_tablesample_rel_pathlist()
|
static |
Definition at line 866 of file allpaths.c.
867{
868 Relids required_outer;
869 Path *path;
870
871 /*
872 * We don't support pushing join clauses into the quals of a samplescan,
873 * but it could still have required parameterization due to LATERAL refs
874 * in its tlist or TABLESAMPLE arguments.
875 */
876 required_outer = rel->lateral_relids;
877
878 /* Consider sampled scan */
880
881 /*
882 * If the sampling method does not support repeatable scans, we must avoid
883 * plans that would scan the rel multiple times. Ideally, we'd simply
884 * avoid putting the rel on the inside of a nestloop join; but adding such
885 * a consideration to the planner seems like a great deal of complication
886 * to support an uncommon usage of second-rate sampling methods. Instead,
887 * if there is a risk that the query might perform an unsafe join, just
888 * wrap the SampleScan in a Materialize node. We can check for joins by
889 * counting the membership of all_query_rels (note that this correctly
890 * counts inheritance trees as single rels). If we're inside a subquery,
891 * we can't easily check whether a join might occur in the outer query, so
892 * just assume one is possible.
893 *
894 * GetTsmRoutine is relatively expensive compared to the other tests here,
895 * so check repeatable_across_scans last, even though that's a bit odd.
896 */
900 {
902 }
903
904 add_path(rel, path);
905
906 /* For the moment, at least, there are no other paths to consider */
907}
Path * create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:1008
MaterialPath * create_material_path(RelOptInfo *rel, Path *subpath)
Definition: pathnode.c:1634
References add_path(), bms_membership(), BMS_SINGLETON, create_material_path(), create_samplescan_path(), GetTsmRoutine(), RelOptInfo::lateral_relids, TsmRoutine::repeatable_across_scans, root, RangeTblEntry::tablesample, and TableSampleClause::tsmhandler.
Referenced by set_rel_pathlist().
◆ set_tablesample_rel_size()
|
static |
Definition at line 826 of file allpaths.c.
827{
829 TsmRoutine *tsm;
830 BlockNumber pages;
831 double tuples;
832
833 /*
834 * Test any partial indexes of rel for applicability. We must do this
835 * first since partial unique indexes can affect size estimates.
836 */
838
839 /*
840 * Call the sampling method's estimation function to estimate the number
841 * of pages it will read and the number of tuples it will return. (Note:
842 * we assume the function returns sane values.)
843 */
846 &pages, &tuples);
847
848 /*
849 * For the moment, because we will only consider a SampleScan path for the
850 * rel, it's okay to just overwrite the pages and tuples estimates for the
851 * whole relation. If we ever consider multiple path types for sampled
852 * rels, we'll need more complication.
853 */
854 rel->pages = pages;
855 rel->tuples = tuples;
856
857 /* Mark rel with estimated output rows, width, etc */
859}
Definition: parsenodes.h:1358
Definition: tsmapi.h:57
SampleScanGetSampleSize_function SampleScanGetSampleSize
Definition: tsmapi.h:68
References TableSampleClause::args, check_index_predicates(), GetTsmRoutine(), RelOptInfo::pages, root, TsmRoutine::SampleScanGetSampleSize, set_baserel_size_estimates(), RangeTblEntry::tablesample, TableSampleClause::tsmhandler, and RelOptInfo::tuples.
Referenced by set_rel_size().
◆ set_values_pathlist()
|
static |
Definition at line 2857 of file allpaths.c.
2858{
2859 Relids required_outer;
2860
2861 /*
2862 * We don't support pushing join clauses into the quals of a values scan,
2863 * but it could still have required parameterization due to LATERAL refs
2864 * in the values expressions.
2865 */
2866 required_outer = rel->lateral_relids;
2867
2868 /* Generate appropriate path */
2870}
Path * create_valuesscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2170
References add_path(), create_valuesscan_path(), RelOptInfo::lateral_relids, and root.
Referenced by set_rel_pathlist().
◆ set_worktable_pathlist()
|
static |
Definition at line 3034 of file allpaths.c.
3035{
3036 Path *ctepath;
3037 PlannerInfo *cteroot;
3038 Index levelsup;
3039 Relids required_outer;
3040
3041 /*
3042 * We need to find the non-recursive term's path, which is in the plan
3043 * level that's processing the recursive UNION, which is one level *below*
3044 * where the CTE comes from.
3045 */
3046 levelsup = rte->ctelevelsup;
3047 if (levelsup == 0) /* shouldn't happen */
3049 levelsup--;
3050 cteroot = root;
3051 while (levelsup-- > 0)
3052 {
3053 cteroot = cteroot->parent_root;
3054 if (!cteroot) /* shouldn't happen */
3056 }
3057 ctepath = cteroot->non_recursive_path;
3058 if (!ctepath) /* shouldn't happen */
3060
3061 /* Mark rel with estimated output rows, width, etc */
3063
3064 /*
3065 * We don't support pushing join clauses into the quals of a worktable
3066 * scan, but it could still have required parameterization due to LATERAL
3067 * refs in its tlist. (I'm not sure this is actually possible given the
3068 * restrictions on recursive references, but it's easy enough to support.)
3069 */
3070 required_outer = rel->lateral_relids;
3071
3072 /* Generate appropriate path */
3074}
Path * create_worktablescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Definition: pathnode.c:2274
References add_path(), create_worktablescan_path(), RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, elog, ERROR, RelOptInfo::lateral_relids, PlannerInfo::non_recursive_path, root, Path::rows, and set_cte_size_estimates().
Referenced by set_rel_size().
◆ standard_join_search()
| RelOptInfo * standard_join_search | ( | PlannerInfo * | root, |
| int | levels_needed, | ||
| List * | initial_rels | ||
| ) |
Definition at line 3451 of file allpaths.c.
3452{
3453 int lev;
3454 RelOptInfo *rel;
3455
3456 /*
3457 * This function cannot be invoked recursively within any one planning
3458 * problem, so join_rel_level[] can't be in use already.
3459 */
3461
3462 /*
3463 * We employ a simple "dynamic programming" algorithm: we first find all
3464 * ways to build joins of two jointree items, then all ways to build joins
3465 * of three items (from two-item joins and single items), then four-item
3466 * joins, and so on until we have considered all ways to join all the
3467 * items into one rel.
3468 *
3469 * root->join_rel_level[j] is a list of all the j-item rels. Initially we
3470 * set root->join_rel_level[1] to represent all the single-jointree-item
3471 * relations.
3472 */
3474
3475 root->join_rel_level[1] = initial_rels;
3476
3477 for (lev = 2; lev <= levels_needed; lev++)
3478 {
3479 ListCell *lc;
3480
3481 /*
3482 * Determine all possible pairs of relations to be joined at this
3483 * level, and build paths for making each one from every available
3484 * pair of lower-level relations.
3485 */
3487
3488 /*
3489 * Run generate_partitionwise_join_paths() and
3490 * generate_useful_gather_paths() for each just-processed joinrel. We
3491 * could not do this earlier because both regular and partial paths
3492 * can get added to a particular joinrel at multiple times within
3493 * join_search_one_level.
3494 *
3495 * After that, we're done creating paths for the joinrel, so run
3496 * set_cheapest().
3497 */
3499 {
3501
3502 /* Create paths for partitionwise joins. */
3504
3505 /*
3506 * Except for the topmost scan/join rel, consider gathering
3507 * partial paths. We'll do the same for the topmost scan/join rel
3508 * once we know the final targetlist (see grouping_planner's and
3509 * its call to apply_scanjoin_target_to_paths).
3510 */
3513
3514 /* Find and save the cheapest paths for this rel */
3515 set_cheapest(rel);
3516
3517#ifdef OPTIMIZER_DEBUG
3518 pprint(rel);
3519#endif
3520 }
3521 }
3522
3523 /*
3524 * We should have a single rel at the final level.
3525 */
3529
3531
3532 root->join_rel_level = NULL;
3533
3534 return rel;
3535}
void join_search_one_level(PlannerInfo *root, int level)
Definition: joinrels.c:73
References Assert(), bms_equal(), elog, ERROR, generate_partitionwise_join_paths(), generate_useful_gather_paths(), 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 3622 of file allpaths.c.
3624{
3625 SetOperationStmt *topop;
3626
3627 /* Check point 1 */
3629 return false;
3630
3631 /* Check point 6 */
3633 return false;
3634
3635 /* Check points 3, 4, and 5 */
3637 subquery->hasWindowFuncs ||
3638 subquery->hasTargetSRFs)
3640
3641 /*
3642 * If we're at a leaf query, check for unsafe expressions in its target
3643 * list, and mark any reasons why they're unsafe in unsafeFlags[].
3644 * (Non-leaf nodes in setop trees have only simple Vars in their tlists,
3645 * so no need to check them.)
3646 */
3648 check_output_expressions(subquery, safetyInfo);
3649
3650 /* Are we at top level, or looking at a setop component? */
3651 if (subquery == topquery)
3652 {
3653 /* Top level, so check any component queries */
3656 safetyInfo))
3657 return false;
3658 }
3659 else
3660 {
3661 /* Setop component must not have more components (too weird) */
3663 return false;
3664 /* Check whether setop component output types match top level */
3666 Assert(topop);
3668 topop->colTypes,
3669 safetyInfo);
3670 }
3671 return true;
3672}
static void compare_tlist_datatypes(List *tlist, List *colTypes, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3819
static void check_output_expressions(Query *subquery, pushdown_safety_info *safetyInfo)
Definition: allpaths.c:3747
References Assert(), castNode, check_output_expressions(), compare_tlist_datatypes(), Query::distinctClause, Query::groupClause, Query::groupingSets, Query::limitCount, Query::limitOffset, recurse_pushdown_safe(), Query::setOperations, Query::targetList, and pushdown_safety_info::unsafeVolatile.
Referenced by recurse_pushdown_safe(), and set_subquery_pathlist().
◆ subquery_push_qual()
|
static |
Definition at line 3996 of file allpaths.c.
3997{
3999 {
4000 /* Recurse to push it separately to each component query */
4002 rte, rti, qual);
4003 }
4004 else
4005 {
4006 /*
4007 * We need to replace Vars in the qual (which must refer to outputs of
4008 * the subquery) with copies of the subquery's targetlist expressions.
4009 * Note that at this point, any uplevel Vars in the qual should have
4010 * been replaced with Params, so they need no work.
4011 *
4012 * This step also ensures that when we are pushing into a setop tree,
4013 * each component query gets its own copy of the qual.
4014 */
4015 qual = ReplaceVarsFromTargetList(qual, rti, 0, rte,
4016 subquery->targetList,
4017 subquery->resultRelation,
4018 REPLACEVARS_REPORT_ERROR, 0,
4019 &subquery->hasSubLinks);
4020
4021 /*
4022 * Now attach the qual to the proper place: normally WHERE, but if the
4023 * subquery uses grouping or aggregation, put it in HAVING (since the
4024 * qual really refers to the group-result rows).
4025 */
4026 if (subquery->hasAggs || subquery->groupClause || subquery->groupingSets || subquery->havingQual)
4028 else
4031
4032 /*
4033 * We need not change the subquery's hasAggs or hasSubLinks flags,
4034 * since we can't be pushing down any aggregates that weren't there
4035 * before, and we don't push down subselects at all.
4036 */
4037 }
4038}
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:1961
References 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 3852 of file allpaths.c.
References InvalidOid, lfirst, WindowClause::partitionClause, targetIsInSortList(), and Query::windowClause.
Referenced by check_output_expressions().
Variable Documentation
◆ enable_geqo
| bool enable_geqo = false |
Definition at line 79 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ geqo_threshold
| int geqo_threshold |
Definition at line 80 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ join_search_hook
| join_search_hook_type join_search_hook = NULL |
Definition at line 88 of file allpaths.c.
Referenced by make_rel_from_joinlist().
◆ min_parallel_index_scan_size
| int min_parallel_index_scan_size |
Definition at line 82 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 81 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 85 of file allpaths.c.
Referenced by set_rel_pathlist().
