Loading...
Searching...
No Matches
planner.c File Reference
#include "postgres.h"#include <limits.h>#include <math.h>#include "access/genam.h"#include "access/parallel.h"#include "access/sysattr.h"#include "access/table.h"#include "catalog/pg_aggregate.h"#include "catalog/pg_inherits.h"#include "catalog/pg_proc.h"#include "catalog/pg_type.h"#include "executor/executor.h"#include "foreign/fdwapi.h"#include "jit/jit.h"#include "lib/bipartite_match.h"#include "lib/knapsack.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/optimizer.h"#include "optimizer/paramassign.h"#include "optimizer/pathnode.h"#include "optimizer/paths.h"#include "optimizer/plancat.h"#include "optimizer/planmain.h"#include "optimizer/planner.h"#include "optimizer/prep.h"#include "optimizer/subselect.h"#include "optimizer/tlist.h"#include "parser/analyze.h"#include "parser/parse_agg.h"#include "parser/parse_clause.h"#include "parser/parse_relation.h"#include "parser/parsetree.h"#include "partitioning/partdesc.h"#include "rewrite/rewriteManip.h"#include "utils/acl.h"#include "utils/backend_status.h"#include "utils/lsyscache.h"#include "utils/rel.h"#include "utils/selfuncs.h"
Include dependency graph for planner.c:
Go to the source code of this file.
Data Structures | |
| struct | grouping_sets_data |
| struct | WindowClauseSortData |
| struct | standard_qp_extra |
| struct | having_grouping_ctx |
Macro Definition Documentation
◆ EXPRKIND_APPINFO
◆ EXPRKIND_ARBITER_ELEM
◆ EXPRKIND_GROUPEXPR
◆ EXPRKIND_LIMIT
◆ EXPRKIND_PHV
◆ EXPRKIND_QUAL
◆ EXPRKIND_RTFUNC
◆ EXPRKIND_RTFUNC_LATERAL
◆ EXPRKIND_TABLEFUNC
◆ EXPRKIND_TABLEFUNC_LATERAL
◆ EXPRKIND_TABLESAMPLE
◆ EXPRKIND_TARGET
◆ EXPRKIND_VALUES
◆ EXPRKIND_VALUES_LATERAL
Function Documentation
◆ add_paths_to_grouping_rel()
|
static |
Definition at line 7345 of file planner.c.
7351{
7362
7363 /*
7364 * Estimate number of groups for non-split aggregation.
7365 */
7367 cheapest_path->rows,
7368 gd,
7369 extra->targetList);
7370
7372 {
7374 partially_grouped_rel->cheapest_total_path;
7375
7376 /*
7377 * Estimate number of groups for final phase of partial aggregation.
7378 */
7379 dNumFinalGroups =
7381 cheapest_partially_grouped_path->rows,
7382 gd,
7383 extra->targetList);
7384 }
7385
7387 {
7388 /*
7389 * Use any available suitably-sorted path as input, and also consider
7390 * sorting the cheapest-total path and incremental sort on any paths
7391 * with presorted keys.
7392 */
7394 {
7399
7400 /* generate alternative group orderings that might be useful */
7402
7404
7406 {
7408
7409 /* restore the path (we replace it in the loop) */
7410 path = path_save;
7411
7413 grouped_rel,
7414 path,
7415 cheapest_path,
7416 info->pathkeys,
7417 -1.0);
7419 continue;
7420
7421 /* Now decide what to stick atop it */
7423 {
7427 }
7429 {
7430 /*
7431 * We have aggregation, possibly with plain GROUP BY. Make
7432 * an AggPath.
7433 */
7436 grouped_rel,
7437 path,
7438 grouped_rel->reltarget,
7440 AGGSPLIT_SIMPLE,
7441 info->clauses,
7442 havingQual,
7443 agg_costs,
7444 dNumGroups));
7445 }
7447 {
7448 /*
7449 * We have GROUP BY without aggregation or grouping sets.
7450 * Make a GroupPath.
7451 */
7454 grouped_rel,
7455 path,
7456 info->clauses,
7457 havingQual,
7458 dNumGroups));
7459 }
7460 else
7461 {
7462 /* Other cases should have been handled above */
7464 }
7465 }
7466 }
7467
7468 /*
7469 * Instead of operating directly on the input relation, we can
7470 * consider finalizing a partially aggregated path.
7471 */
7473 {
7475 {
7480
7481 /* generate alternative group orderings that might be useful */
7483
7485
7486 /* process all potentially interesting grouping reorderings */
7488 {
7490
7491 /* restore the path (we replace it in the loop) */
7492 path = path_save;
7493
7495 grouped_rel,
7496 path,
7498 info->pathkeys,
7499 -1.0);
7500
7502 continue;
7503
7507 grouped_rel,
7508 path,
7509 grouped_rel->reltarget,
7511 AGGSPLIT_FINAL_DESERIAL,
7512 info->clauses,
7513 havingQual,
7514 agg_final_costs,
7515 dNumFinalGroups));
7516 else
7519 grouped_rel,
7520 path,
7521 info->clauses,
7522 havingQual,
7523 dNumFinalGroups));
7524
7525 }
7526 }
7527 }
7528 }
7529
7531 {
7533 {
7534 /*
7535 * Try for a hash-only groupingsets path over unsorted input.
7536 */
7540 }
7541 else
7542 {
7543 /*
7544 * Generate a HashAgg Path. We just need an Agg over the
7545 * cheapest-total input path, since input order won't matter.
7546 */
7549 cheapest_path,
7550 grouped_rel->reltarget,
7551 AGG_HASHED,
7552 AGGSPLIT_SIMPLE,
7553 root->processed_groupClause,
7554 havingQual,
7555 agg_costs,
7556 dNumGroups));
7557 }
7558
7559 /*
7560 * Generate a Finalize HashAgg Path atop of the cheapest partially
7561 * grouped path, assuming there is one
7562 */
7564 {
7567 grouped_rel,
7569 grouped_rel->reltarget,
7570 AGG_HASHED,
7571 AGGSPLIT_FINAL_DESERIAL,
7572 root->processed_groupClause,
7573 havingQual,
7574 agg_final_costs,
7575 dNumFinalGroups));
7576 }
7577 }
7578
7579 /*
7580 * When partitionwise aggregate is used, we might have fully aggregated
7581 * paths in the partial pathlist, because add_paths_to_append_rel() will
7582 * consider a path for grouped_rel consisting of a Parallel Append of
7583 * non-partial paths from each child.
7584 */
7587}
List * get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
Definition pathkeys.c:467
GroupPath * create_group_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *groupClause, List *qual, double numGroups)
Definition pathnode.c:2948
AggPath * create_agg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, AggStrategy aggstrategy, AggSplit aggsplit, List *groupClause, List *qual, const AggClauseCosts *aggcosts, double numGroups)
Definition pathnode.c:3057
static void gather_grouping_paths(PlannerInfo *root, RelOptInfo *rel)
Definition planner.c:8017
static Path * make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path, Path *cheapest_path, List *pathkeys, double limit_tuples)
Definition planner.c:7958
static void consider_groupingsets_paths(PlannerInfo *root, RelOptInfo *grouped_rel, Path *path, bool is_sorted, bool can_hash, grouping_sets_data *gd, const AggClauseCosts *agg_costs, double dNumGroups)
Definition planner.c:4434
static double get_number_of_groups(PlannerInfo *root, double path_rows, grouping_sets_data *gd, List *target_list)
Definition planner.c:3928
Definition pathnodes.h:132
Definition pathnodes.h:1829
Definition pg_list.h:54
Definition pathnodes.h:1965
Definition parsenodes.h:121
Definition pg_list.h:46
References add_path(), GroupPathExtraData::agg_final_costs, AGG_HASHED, AGG_PLAIN, AGG_SORTED, AGGSPLIT_FINAL_DESERIAL, AGGSPLIT_SIMPLE, Assert, GroupByOrdering::clauses, consider_groupingsets_paths(), create_agg_path(), create_group_path(), fb(), GroupPathExtraData::flags, gather_grouping_paths(), get_number_of_groups(), get_useful_group_keys_orderings(), GROUPING_CAN_USE_HASH, GROUPING_CAN_USE_SORT, GroupPathExtraData::havingQual, lfirst, list_length(), make_ordered_path(), NIL, parse(), RelOptInfo::partial_pathlist, GroupByOrdering::pathkeys, RelOptInfo::reltarget, root, and GroupPathExtraData::targetList.
Referenced by create_ordinary_grouping_paths().
◆ adjust_group_pathkeys_for_groupagg()
|
static |
Definition at line 3499 of file planner.c.
3500{
3507
3508 /* Shouldn't be here if there are grouping sets */
3510 /* Shouldn't be here unless there are some ordered aggregates */
3512
3513 /* Do nothing if disabled */
3515 return;
3516
3517 /*
3518 * Make a first pass over all AggInfos to collect a Bitmapset containing
3519 * the indexes of all AggInfos to be processed below.
3520 */
3523 {
3526
3528 continue;
3529
3530 /* Skip unless there's a DISTINCT or ORDER BY clause */
3532 continue;
3533
3534 /* Additional safety checks are needed if there's a FILTER clause */
3536 {
3539
3540 /*
3541 * When the Aggref has a FILTER clause, it's possible that the
3542 * filter removes rows that cannot be sorted because the
3543 * expression to sort by results in an error during its
3544 * evaluation. This is a problem for presorting as that happens
3545 * before the FILTER, whereas without presorting, the Aggregate
3546 * node will apply the FILTER *before* sorting. So that we never
3547 * try to sort anything that might error, here we aim to skip over
3548 * any Aggrefs with arguments with expressions which, when
3549 * evaluated, could cause an ERROR. Vars and Consts are ok. There
3550 * may be more cases that should be allowed, but more thought
3551 * needs to be given. Err on the side of caution.
3552 */
3554 {
3557
3560
3561 /* Common case, Vars and Consts are ok */
3563 continue;
3564
3565 /* Unsupported. Don't try to presort for this Aggref */
3567 break;
3568 }
3569
3570 /* Skip unsupported Aggrefs */
3572 continue;
3573 }
3574
3577 }
3578
3579 /*
3580 * Now process all the unprocessed_aggs to find the best set of pathkeys
3581 * for the given set of aggregates.
3582 *
3583 * On the first outer loop here 'bestaggs' will be empty. We'll populate
3584 * this during the first loop using the pathkeys for the very first
3585 * AggInfo then taking any stronger pathkeys from any other AggInfos with
3586 * a more strict set of compatible pathkeys. Once the outer loop is
3587 * complete, we mark off all the aggregates with compatible pathkeys then
3588 * remove those from the unprocessed_aggs and repeat the process to try to
3589 * find another set of pathkeys that are suitable for a larger number of
3590 * aggregates. The outer loop will stop when there are not enough
3591 * unprocessed aggregates for it to be possible to find a set of pathkeys
3592 * to suit a larger number of aggregates.
3593 */
3597 {
3600
3601 i = -1;
3603 {
3607 List *pathkeys;
3608
3611 else
3613
3615 aggref->args);
3616
3617 /*
3618 * Ignore Aggrefs which have volatile functions in their ORDER BY
3619 * or DISTINCT clause.
3620 */
3622 {
3624 continue;
3625 }
3626
3627 /*
3628 * When not set yet, take the pathkeys from the first unprocessed
3629 * aggregate.
3630 */
3632 {
3633 currpathkeys = pathkeys;
3634
3635 /* include the GROUP BY pathkeys, if they exist */
3638 currpathkeys);
3639
3640 /* record that we found pathkeys for this aggregate */
3642 }
3643 else
3644 {
3645 /* now look for a stronger set of matching pathkeys */
3646
3647 /* include the GROUP BY pathkeys, if they exist */
3650 pathkeys);
3651
3652 /* are 'pathkeys' compatible or better than 'currpathkeys'? */
3654 {
3656 /* 'pathkeys' are stronger, use these ones instead */
3657 currpathkeys = pathkeys;
3658 pg_fallthrough;
3659
3661 /* 'pathkeys' are less strict */
3662 pg_fallthrough;
3663
3665 /* mark this aggregate as covered by 'currpathkeys' */
3667 break;
3668
3670 break;
3671 }
3672 }
3673 }
3674
3675 /* remove the aggregates that we've just processed */
3677
3678 /*
3679 * If this pass included more aggregates than the previous best then
3680 * use these ones as the best set.
3681 */
3683 {
3686 }
3687 }
3688
3689 /*
3690 * If we found any ordered aggregates, update root->group_pathkeys to add
3691 * the best set of aggregate pathkeys. Note that bestpathkeys includes
3692 * the original GROUP BY pathkeys already.
3693 */
3696
3697 /*
3698 * Now that we've found the best set of aggregates we can set the
3699 * presorted flag to indicate to the executor that it needn't bother
3700 * performing a sort for these Aggrefs. We're able to do this now as
3701 * there's no chance of a Hash Aggregate plan as create_grouping_paths
3702 * will not mark the GROUP BY as GROUPING_CAN_USE_HASH due to the presence
3703 * of ordered aggregates.
3704 */
3705 i = -1;
3707 {
3709
3711 {
3713
3714 aggref->aggpresorted = true;
3715 }
3716 }
3717}
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1145
List * make_pathkeys_for_sortclauses(PlannerInfo *root, List *sortclauses, List *tlist)
Definition pathkeys.c:1336
PathKeysComparison compare_pathkeys(List *keys1, List *keys2)
Definition pathkeys.c:304
Definition pathnodes.h:3756
Definition primnodes.h:457
Definition bitmapset.h:50
Definition primnodes.h:328
Definition primnodes.h:190
Definition primnodes.h:1198
Definition primnodes.h:2256
Definition primnodes.h:263
References Aggref::aggdistinct, Aggref::aggfilter, Aggref::aggorder, append_pathkeys(), arg, Aggref::args, Assert, bms_add_member(), bms_del_member(), bms_del_members(), bms_next_member(), bms_num_members(), castNode, compare_pathkeys(), enable_presorted_aggregate, fb(), foreach_current_index, has_volatile_pathkey(), i, IsA, lfirst, lfirst_node, linitial_node, list_copy(), list_nth_node, make_pathkeys_for_sortclauses(), NIL, PATHKEYS_BETTER1, PATHKEYS_BETTER2, PATHKEYS_DIFFERENT, PATHKEYS_EQUAL, pg_fallthrough, and root.
Referenced by standard_qp_callback().
◆ adjust_paths_for_srfs()
|
static |
Definition at line 6894 of file planner.c.
6896{
6898
6901
6902 /* If no SRFs appear at this plan level, nothing to do */
6904 return;
6905
6906 /*
6907 * Stack SRF-evaluation nodes atop each path for the rel.
6908 *
6909 * In principle we should re-run set_cheapest() here to identify the
6910 * cheapest path, but it seems unlikely that adding the same tlist eval
6911 * costs to all the paths would change that, so we don't bother. Instead,
6912 * just assume that the cheapest-startup and cheapest-total paths remain
6913 * so. (There should be no parameterized paths anymore, so we needn't
6914 * worry about updating cheapest_parameterized_paths.)
6915 */
6917 {
6921 *lc2;
6922
6925 {
6928
6929 /* If this level doesn't contain SRFs, do regular projection */
6932 rel,
6933 newpath,
6934 thistarget);
6935 else
6937 rel,
6938 newpath,
6939 thistarget);
6940 }
6946 }
6947
6948 /* Likewise for partial paths, if any */
6950 {
6954 *lc2;
6955
6958 {
6961
6962 /* If this level doesn't contain SRFs, do regular projection */
6965 rel,
6966 newpath,
6967 thistarget);
6968 else
6969 {
6970 /* avoid apply_projection_to_path, in case of multiple refs */
6972 rel,
6973 newpath,
6974 thistarget);
6975 }
6976 }
6978 }
6979}
ProjectSetPath * create_set_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
Definition pathnode.c:2785
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
Definition pathnode.c:2587
Path * apply_projection_to_path(PlannerInfo *root, RelOptInfo *rel, Path *path, PathTarget *target)
Definition pathnode.c:2696
Definition pathnodes.h:1872
References apply_projection_to_path(), Assert, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, create_projection_path(), create_set_projection_path(), fb(), forboth, lfirst, lfirst_int, lfirst_node, linitial_int, list_length(), RelOptInfo::partial_pathlist, RelOptInfo::pathlist, root, and subpath().
Referenced by apply_scanjoin_target_to_paths(), and grouping_planner().
◆ apply_scanjoin_target_to_paths()
|
static |
Definition at line 8142 of file planner.c.
8148{
8152
8153 /* This recurses, so be paranoid. */
8154 check_stack_depth();
8155
8156 /*
8157 * If the rel only has Append and MergeAppend paths, we want to drop its
8158 * existing paths and generate new ones. This function would still be
8159 * correct if we kept the existing paths: we'd modify them to generate the
8160 * correct target above the partitioning Append, and then they'd compete
8161 * on cost with paths generating the target below the Append. However, in
8162 * our current cost model the latter way is always the same or cheaper
8163 * cost, so modifying the existing paths would just be useless work.
8164 * Moreover, when the cost is the same, varying roundoff errors might
8165 * sometimes allow an existing path to be picked, resulting in undesirable
8166 * cross-platform plan variations. So we drop old paths and thereby force
8167 * the work to be done below the Append.
8168 *
8169 * However, there are several cases when this optimization is not safe. If
8170 * the rel isn't partitioned, then none of the paths will be Append or
8171 * MergeAppend paths, so we should definitely not do this. If it is
8172 * partitioned but is a joinrel, it may have Append and MergeAppend paths,
8173 * but it can also have join paths that we can't afford to discard.
8174 *
8175 * Some care is needed, because we have to allow
8176 * generate_useful_gather_paths to see the old partial paths in the next
8177 * stanza. Hence, zap the main pathlist here, then allow
8178 * generate_useful_gather_paths to add path(s) to the main list, and
8179 * finally zap the partial pathlist.
8180 */
8183
8184 /*
8185 * If the scan/join target is not parallel-safe, partial paths cannot
8186 * generate it.
8187 */
8189 {
8190 /*
8191 * Since we can't generate the final scan/join target in parallel
8192 * workers, this is our last opportunity to use any partial paths that
8193 * exist; so build Gather path(s) that use them and emit whatever the
8194 * current reltarget is. We don't do this in the case where the
8195 * target is parallel-safe, since we will be able to generate superior
8196 * paths by doing it after the final scan/join target has been
8197 * applied.
8198 */
8200
8201 /* Can't use parallel query above this level. */
8204 }
8205
8206 /* Finish dropping old paths for a partitioned rel, per comment above */
8209
8210 /* Extract SRF-free scan/join target. */
8212
8213 /*
8214 * Apply the SRF-free scan/join target to each existing path.
8215 *
8216 * If the tlist exprs are the same, we can just inject the sortgroupref
8217 * information into the existing pathtargets. Otherwise, replace each
8218 * path with a projection path that generates the SRF-free scan/join
8219 * target. This can't change the ordering of paths within rel->pathlist,
8220 * so we just modify the list in place.
8221 */
8223 {
8225
8226 /* Shouldn't have any parameterized paths anymore */
8228
8230 subpath->pathtarget->sortgrouprefs =
8231 scanjoin_target->sortgrouprefs;
8232 else
8233 {
8235
8237 scanjoin_target);
8239 }
8240 }
8241
8242 /* Likewise adjust the targets for any partial paths. */
8244 {
8246
8247 /* Shouldn't have any parameterized paths anymore */
8249
8251 subpath->pathtarget->sortgrouprefs =
8252 scanjoin_target->sortgrouprefs;
8253 else
8254 {
8256
8258 scanjoin_target);
8260 }
8261 }
8262
8263 /*
8264 * Now, if final scan/join target contains SRFs, insert ProjectSetPath(s)
8265 * atop each existing path. (Note that this function doesn't look at the
8266 * cheapest-path fields, which is a good thing because they're bogus right
8267 * now.)
8268 */
8271 scanjoin_targets,
8273
8274 /*
8275 * Update the rel's target to be the final (with SRFs) scan/join target.
8276 * This now matches the actual output of all the paths, and we might get
8277 * confused in createplan.c if they don't agree. We must do this now so
8278 * that any append paths made in the next part will use the correct
8279 * pathtarget (cf. create_append_path).
8280 *
8281 * Note that this is also necessary if GetForeignUpperPaths() gets called
8282 * on the final scan/join relation or on any of its children, since the
8283 * FDW might look at the rel's target to create ForeignPaths.
8284 */
8286
8287 /*
8288 * If the relation is partitioned, recursively apply the scan/join target
8289 * to all partitions, and generate brand-new Append paths in which the
8290 * scan/join target is computed below the Append rather than above it.
8291 * Since Append is not projection-capable, that might save a separate
8292 * Result node, and it also is important for partitionwise aggregate.
8293 */
8295 {
8298
8299 /* Adjust each partition. */
8300 i = -1;
8302 {
8304 AppendRelInfo **appinfos;
8305 int nappinfos;
8307
8309
8310 /* Dummy children can be ignored. */
8312 continue;
8313
8314 /* Translate scan/join targets for this child. */
8316 &nappinfos);
8318 {
8320
8321 target = copy_pathtarget(target);
8325 nappinfos, appinfos);
8327 target);
8328 }
8329 pfree(appinfos);
8330
8331 /* Recursion does the real work. */
8333 child_scanjoin_targets,
8336 tlist_same_exprs);
8337
8338 /* Save non-dummy children for Append paths. */
8341 }
8342
8343 /* Build new paths for this relation by appending child paths. */
8345 }
8346
8347 /*
8348 * Consider generating Gather or Gather Merge paths. We must only do this
8349 * if the relation is parallel safe, and we don't do it for child rels to
8350 * avoid creating multiple Gather nodes within the same plan. We must do
8351 * this after all paths have been generated and before set_cheapest, since
8352 * one of the generated paths may turn out to be the cheapest one.
8353 */
8356
8357 /*
8358 * Reassess which paths are the cheapest, now that we've potentially added
8359 * new Gather (or Gather Merge) and/or Append (or MergeAppend) paths to
8360 * this relation.
8361 */
8362 set_cheapest(rel);
8363}
void generate_useful_gather_paths(PlannerInfo *root, RelOptInfo *rel, bool override_rows)
Definition allpaths.c:3392
void add_paths_to_append_rel(PlannerInfo *root, RelOptInfo *rel, List *live_childrels)
Definition allpaths.c:1420
AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
Definition appendinfo.c:809
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Definition appendinfo.c:201
static void apply_scanjoin_target_to_paths(PlannerInfo *root, RelOptInfo *rel, List *scanjoin_targets, List *scanjoin_targets_contain_srfs, bool scanjoin_target_parallel_safe, bool tlist_same_exprs)
Definition planner.c:8142
static void adjust_paths_for_srfs(PlannerInfo *root, RelOptInfo *rel, List *targets, List *targets_contain_srfs)
Definition planner.c:6894
Definition pathnodes.h:3290
Definition nodes.h:133
Definition pathnodes.h:1010
References add_paths_to_append_rel(), adjust_appendrel_attrs(), adjust_paths_for_srfs(), apply_scanjoin_target_to_paths(), Assert, bms_next_member(), check_stack_depth(), RelOptInfo::consider_parallel, copy_pathtarget(), create_projection_path(), PathTarget::exprs, fb(), find_appinfos_by_relids(), generate_useful_gather_paths(), i, IS_DUMMY_REL, IS_OTHER_REL, IS_PARTITIONED_REL, IS_SIMPLE_REL, lappend(), lfirst, lfirst_node, linitial_node, RelOptInfo::live_parts, llast_node, NIL, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, pfree(), RelOptInfo::reltarget, root, set_cheapest(), subpath(), and tlist_same_exprs().
Referenced by apply_scanjoin_target_to_paths(), and grouping_planner().
◆ can_partial_agg()
|
static |
Definition at line 8100 of file planner.c.
8101{
8103
8105 {
8106 /*
8107 * We don't know how to do parallel aggregation unless we have either
8108 * some aggregates or a grouping clause.
8109 */
8110 return false;
8111 }
8113 {
8114 /* We don't know how to do grouping sets in parallel. */
8115 return false;
8116 }
8118 {
8119 /* Insufficient support for partial mode. */
8120 return false;
8121 }
8122
8123 /* Everything looks good. */
8124 return true;
8125}
References NIL, parse(), and root.
Referenced by create_grouping_paths().
◆ choose_plan_name()
| char * choose_plan_name | ( | PlannerGlobal * | glob, |
| const char * | name, | ||
| bool | always_number | ||
| ) |
Definition at line 9215 of file planner.c.
9216{
9217 unsigned n;
9218
9219 /*
9220 * If a numeric suffix is not required, then search the list of
9221 * previously-assigned names for a match. If none is found, then we can
9222 * use the provided name without modification.
9223 */
9225 {
9226 bool found = false;
9227
9229 {
9231 {
9232 found = true;
9233 break;
9234 }
9235 }
9236
9237 if (!found)
9238 {
9239 /* pstrdup here is just to avoid cast-away-const */
9241
9244 }
9245 }
9246
9247 /*
9248 * If a numeric suffix is required or if the un-suffixed name is already
9249 * in use, then loop until we find a positive integer that produces a
9250 * novel name.
9251 */
9252 for (n = 1; true; ++n)
9253 {
9255 bool found = false;
9256
9258 {
9260 {
9261 found = true;
9262 break;
9263 }
9264 }
9265
9266 if (!found)
9267 {
9270 }
9271
9273 }
9274}
References fb(), foreach_ptr, lappend(), name, pfree(), psprintf(), and pstrdup().
Referenced by build_minmax_path(), make_subplan(), recurse_set_operations(), set_subquery_pathlist(), and SS_process_ctes().
◆ common_prefix_cmp()
Definition at line 6355 of file planner.c.
6356{
6361
6363 {
6366
6368 return -1;
6370 return 1;
6372 return -1;
6374 return 1;
6376 return -1;
6378 return 1;
6379 /* no need to compare eqop, since it is fully determined by sortop */
6380 }
6381
6383 return -1;
6385 return 1;
6386
6387 return 0;
6388}
Definition parsenodes.h:1555
Definition planner.c:122
References a, b, fb(), forboth, lfirst_node, and list_length().
Referenced by select_active_windows().
◆ consider_groupingsets_paths()
|
static |
Definition at line 4434 of file planner.c.
4442{
4445
4446 /*
4447 * If we're not being offered sorted input, then only consider plans that
4448 * can be done entirely by hashing.
4449 *
4450 * We can hash everything if it looks like it'll fit in hash_mem. But if
4451 * the input is actually sorted despite not being advertised as such, we
4452 * prefer to make use of that in order to use less memory.
4453 *
4454 * If none of the grouping sets are sortable, then ignore the hash_mem
4455 * limit and generate a path anyway, since otherwise we'll just fail.
4456 */
4458 {
4469
4471
4472 /*
4473 * If the input is coincidentally sorted usefully (which can happen
4474 * even if is_sorted is false, since that only means that our caller
4475 * has set up the sorting for us), then save some hashtable space by
4476 * making use of that. But we need to watch out for degenerate cases:
4477 *
4478 * 1) If there are any empty grouping sets, then group_pathkeys might
4479 * be NIL if all non-empty grouping sets are unsortable. In this case,
4480 * there will be a rollup containing only empty groups, and the
4481 * pathkeys_contained_in test is vacuously true; this is ok.
4482 *
4483 * XXX: the above relies on the fact that group_pathkeys is generated
4484 * from the first rollup. If we add the ability to consider multiple
4485 * sort orders for grouping input, this assumption might fail.
4486 *
4487 * 2) If there are no empty sets and only unsortable sets, then the
4488 * rollups list will be empty (and thus l_start == NULL), and
4489 * group_pathkeys will be NIL; we must ensure that the vacuously-true
4490 * pathkeys_contained_in test doesn't cause us to crash.
4491 */
4494 {
4498 }
4499
4501 path,
4502 agg_costs,
4504
4505 /*
4506 * gd->rollups is empty if we have only unsortable columns to work
4507 * with. Override hash_mem in that case; otherwise, we'll rely on the
4508 * sorted-input case to generate usable mixed paths.
4509 */
4511 return; /* nope, won't fit */
4512
4513 /*
4514 * We need to burst the existing rollups list into individual grouping
4515 * sets and recompute a groupClause for each set.
4516 */
4518
4520 {
4522
4523 /*
4524 * If we find an unhashable rollup that's not been skipped by the
4525 * "actually sorted" check above, we can't cope; we'd need sorted
4526 * input (with a different sort order) but we can't get that here.
4527 * So bail out; we'll get a valid path from the is_sorted case
4528 * instead.
4529 *
4530 * The mere presence of empty grouping sets doesn't make a rollup
4531 * unhashable (see preprocess_grouping_sets), we handle those
4532 * specially below.
4533 */
4535 return;
4536
4538 }
4540 {
4544
4546 {
4547 /* Empty grouping sets can't be hashed. */
4550 }
4551 else
4552 {
4554
4558 rollup->gsets_data,
4559 gd->tleref_to_colnum_map);
4564 }
4565 }
4566
4567 /*
4568 * If we didn't find anything nonempty to hash, then bail. We'll
4569 * generate a path from the is_sorted case.
4570 */
4572 return;
4573
4574 /*
4575 * If there were empty grouping sets they should have been in the
4576 * first rollup.
4577 */
4579
4581 {
4584 }
4586 {
4588
4597 }
4598
4601 grouped_rel,
4602 path,
4604 strat,
4605 new_rollups,
4606 agg_costs));
4607 return;
4608 }
4609
4610 /*
4611 * If we have sorted input but nothing we can do with it, bail.
4612 */
4614 return;
4615
4616 /*
4617 * Given sorted input, we try and make two paths: one sorted and one mixed
4618 * sort/hash. (We need to try both because hashagg might be disabled, or
4619 * some columns might not be sortable.)
4620 *
4621 * can_hash is passed in as false if some obstacle elsewhere (such as
4622 * ordered aggs) means that we shouldn't consider hashing at all.
4623 */
4625 {
4630
4631 /*
4632 * Account first for space needed for groups we can't sort at all.
4633 */
4635 path,
4636 agg_costs,
4637 gd->dNumHashGroups);
4638
4640 {
4647
4648 /*
4649 * We treat this as a knapsack problem: the knapsack capacity
4650 * represents hash_mem, the item weights are the estimated memory
4651 * usage of the hashtables needed to implement a single rollup,
4652 * and we really ought to use the cost saving as the item value;
4653 * however, currently the costs assigned to sort nodes don't
4654 * reflect the comparison costs well, and so we treat all items as
4655 * of equal value (each rollup we hash instead saves us one sort).
4656 *
4657 * To use the discrete knapsack, we need to scale the values to a
4658 * reasonably small bounded range. We choose to allow a 5% error
4659 * margin; we have no more than 4096 rollups in the worst possible
4660 * case, which with a 5% error margin will require a bit over 42MB
4661 * of workspace. (Anyone wanting to plan queries that complex had
4662 * better have the memory for it. In more reasonable cases, with
4663 * no more than a couple of dozen rollups, the memory usage will
4664 * be negligible.)
4665 *
4666 * k_capacity is naturally bounded, but we clamp the values for
4667 * scale and weight (below) to avoid overflows or underflows (or
4668 * uselessly trying to use a scale factor less than 1 byte).
4669 */
4672
4673 /*
4674 * We leave the first rollup out of consideration since it's the
4675 * one that matches the input sort order. We assign indexes "i"
4676 * to only those entries considered for hashing; the second loop,
4677 * below, must use the same condition.
4678 */
4679 i = 0;
4681 {
4683
4685 {
4687 path,
4688 agg_costs,
4689 rollup->numGroups);
4690
4691 /*
4692 * If sz is enormous, but hash_mem (and hence scale) is
4693 * small, avoid integer overflow here.
4694 */
4696 k_capacity + 1.0);
4697 ++i;
4698 }
4699 }
4700
4701 /*
4702 * Apply knapsack algorithm; compute the set of items which
4703 * maximizes the value stored (in this case the number of sorts
4704 * saved) while keeping the total size (approximately) within
4705 * capacity.
4706 */
4709
4711 {
4713
4714 i = 0;
4716 {
4718
4720 {
4723 rollup->gsets_data);
4724 else
4726 ++i;
4727 }
4728 else
4730 }
4731 }
4732 }
4733
4736
4738 {
4741
4743
4747 rollup->gsets_data,
4748 gd->tleref_to_colnum_map);
4753 }
4754
4755 if (rollups)
4756 {
4759 grouped_rel,
4760 path,
4762 AGG_MIXED,
4763 rollups,
4764 agg_costs));
4765 }
4766 }
4767
4768 /*
4769 * Now try the simple sorted case.
4770 */
4774 grouped_rel,
4775 path,
4777 AGG_SORTED,
4778 gd->rollups,
4779 agg_costs));
4780}
Bitmapset * DiscreteKnapsack(int max_weight, int num_items, int *item_weights, double *item_values)
Definition knapsack.c:51
GroupingSetsPath * create_groupingsets_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *having_qual, AggStrategy aggstrategy, List *rollups, const AggClauseCosts *agg_costs)
Definition pathnode.c:3139
static List * preprocess_groupclause(PlannerInfo *root, List *force)
Definition planner.c:3098
static List * remap_to_groupclause_idx(List *groupClause, List *gsets, int *tleref_to_colnum_map)
Definition planner.c:2632
double estimate_hashagg_tablesize(PlannerInfo *root, Path *path, const AggClauseCosts *agg_costs, double dNumGroups)
Definition selfuncs.c:4528
Definition pathnodes.h:2606
Definition pathnodes.h:2615
References add_path(), AGG_HASHED, AGG_MIXED, AGG_SORTED, Assert, bms_is_empty, bms_is_member(), create_groupingsets_path(), DiscreteKnapsack(), estimate_hashagg_tablesize(), fb(), for_each_cell, for_each_from, get_hash_memory_limit(), i, lappend(), lcons(), lfirst_node, linitial, list_concat(), list_copy(), list_head(), list_length(), list_make1, lnext(), makeNode, Max, Min, NIL, palloc(), parse(), Path::pathkeys, pathkeys_contained_in(), preprocess_groupclause(), remap_to_groupclause_idx(), root, and scale.
Referenced by add_paths_to_grouping_rel().
◆ create_degenerate_grouping_paths()
|
static |
Definition at line 4240 of file planner.c.
4242{
4244 int nrows;
4245 Path *path;
4246
4248 if (nrows > 1)
4249 {
4250 /*
4251 * Doesn't seem worthwhile writing code to cons up a generate_series
4252 * or a values scan to emit multiple rows. Instead just make N clones
4253 * and append them. (With a volatile HAVING clause, this means you
4254 * might get between 0 and N output rows. Offhand I think that's
4255 * desired.)
4256 */
4258
4259 while (--nrows >= 0)
4260 {
4261 path = (Path *)
4263 grouped_rel->reltarget,
4266 }
4267 path = (Path *)
4269 grouped_rel,
4270 append,
4271 NIL,
4272 NULL,
4273 0,
4274 false,
4275 -1);
4276 }
4277 else
4278 {
4279 /* No grouping sets, or just one, so one output row */
4280 path = (Path *)
4282 grouped_rel->reltarget,
4284 }
4285
4286 add_path(grouped_rel, path);
4287}
AppendPath * create_append_path(PlannerInfo *root, RelOptInfo *rel, AppendPathInput input, List *pathkeys, Relids required_outer, int parallel_workers, bool parallel_aware, double rows)
Definition pathnode.c:1352
GroupResultPath * create_group_result_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *havingqual)
Definition pathnode.c:1664
Definition pathnode.h:35
References add_path(), create_append_path(), create_group_result_path(), fb(), lappend(), list_length(), NIL, parse(), RelOptInfo::reltarget, and root.
Referenced by create_grouping_paths().
◆ create_distinct_paths()
|
static |
Definition at line 5053 of file planner.c.
5055{
5057
5058 /* For now, do all work in the (DISTINCT, NULL) upperrel */
5060
5061 /*
5062 * We don't compute anything at this level, so distinct_rel will be
5063 * parallel-safe if the input rel is parallel-safe. In particular, if
5064 * there is a DISTINCT ON (...) clause, any path for the input_rel will
5065 * output those expressions, and will not be parallel-safe unless those
5066 * expressions are parallel-safe.
5067 */
5069
5070 /*
5071 * If the input rel belongs to a single FDW, so does the distinct_rel.
5072 */
5077
5078 /* build distinct paths based on input_rel's pathlist */
5080
5081 /* now build distinct paths based on input_rel's partial_pathlist */
5083
5084 /* Give a helpful error if we failed to create any paths */
5090
5091 /*
5092 * If there is an FDW that's responsible for all baserels of the query,
5093 * let it consider adding ForeignPaths.
5094 */
5096 distinct_rel->fdwroutine->GetForeignUpperPaths)
5098 UPPERREL_DISTINCT,
5099 input_rel,
5100 distinct_rel,
5101 NULL);
5102
5103 /* Let extensions possibly add some more paths */
5107
5108 /* Now choose the best path(s) */
5110
5112}
int errdetail(const char *fmt,...) pg_attribute_printf(1
static RelOptInfo * create_final_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *distinct_rel)
Definition planner.c:5306
static void create_partial_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *final_distinct_rel, PathTarget *target)
Definition planner.c:5123
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition relnode.c:1617
References create_final_distinct_paths(), create_partial_distinct_paths(), create_upper_paths_hook, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), fetch_upper_rel(), NIL, root, set_cheapest(), and UPPERREL_DISTINCT.
Referenced by grouping_planner().
◆ create_final_distinct_paths()
|
static |
Definition at line 5306 of file planner.c.
5308{
5313
5314 /* Estimate number of distinct rows there will be */
5316 root->hasHavingQual)
5317 {
5318 /*
5319 * If there was grouping or aggregation, use the number of input rows
5320 * as the estimated number of DISTINCT rows (ie, assume the input is
5321 * already mostly unique).
5322 */
5324 }
5325 else
5326 {
5327 /*
5328 * Otherwise, the UNIQUE filter has effects comparable to GROUP BY.
5329 */
5331
5333 parse->targetList);
5335 cheapest_input_path->rows,
5337 }
5338
5339 /*
5340 * Consider sort-based implementations of DISTINCT, if possible.
5341 */
5343 {
5344 /*
5345 * Firstly, if we have any adequately-presorted paths, just stick a
5346 * Unique node on those. We also, consider doing an explicit sort of
5347 * the cheapest input path and Unique'ing that. If any paths have
5348 * presorted keys then we'll create an incremental sort atop of those
5349 * before adding a unique node on the top. We'll also attempt to
5350 * reorder the required pathkeys to match the input path's pathkeys as
5351 * much as possible, in hopes of avoiding a possible need to re-sort.
5352 *
5353 * When we have DISTINCT ON, we must sort by the more rigorous of
5354 * DISTINCT and ORDER BY, else it won't have the desired behavior.
5355 * Also, if we do have to do an explicit sort, we might as well use
5356 * the more rigorous ordering to avoid a second sort later. (Note
5357 * that the parser will have ensured that one clause is a prefix of
5358 * the other.)
5359 */
5363
5368 else
5370
5372 {
5376
5377 useful_pathkeys_list =
5379 needed_pathkeys,
5380 input_path->pathkeys);
5382
5384 {
5386 distinct_rel,
5387 input_path,
5388 cheapest_input_path,
5389 useful_pathkeys,
5390 limittuples);
5391
5393 continue;
5394
5395 /*
5396 * distinct_pathkeys may have become empty if all of the
5397 * pathkeys were determined to be redundant. If all of the
5398 * pathkeys are redundant then each DISTINCT target must only
5399 * allow a single value, therefore all resulting tuples must
5400 * be identical (or at least indistinguishable by an equality
5401 * check). We can uniquify these tuples simply by just taking
5402 * the first tuple. All we do here is add a path to do "LIMIT
5403 * 1" atop of 'sorted_path'. When doing a DISTINCT ON we may
5404 * still have a non-NIL sort_pathkeys list, so we must still
5405 * only do this with paths which are correctly sorted by
5406 * sort_pathkeys.
5407 */
5409 {
5410 Node *limitCount;
5411
5415 true);
5416
5417 /*
5418 * If the query already has a LIMIT clause, then we could
5419 * end up with a duplicate LimitPath in the final plan.
5420 * That does not seem worth troubling over too much.
5421 */
5424 NULL, limitCount,
5425 LIMIT_OPTION_COUNT, 0, 1));
5426 }
5427 else
5428 {
5431 sorted_path,
5433 numDistinctRows));
5434 }
5435 }
5436 }
5437 }
5438
5439 /*
5440 * Consider hash-based implementations of DISTINCT, if possible.
5441 *
5442 * If we were not able to make any other types of path, we *must* hash or
5443 * die trying. If we do have other choices, there are two things that
5444 * should prevent selection of hashing: if the query uses DISTINCT ON
5445 * (because it won't really have the expected behavior if we hash), or if
5446 * enable_hashagg is off.
5447 *
5448 * Note: grouping_is_hashable() is much more expensive to check than the
5449 * other gating conditions, so we want to do it last.
5450 */
5455 else
5457
5459 {
5460 /* Generate hashed aggregate path --- no sort needed */
5463 distinct_rel,
5464 cheapest_input_path,
5465 cheapest_input_path->pathtarget,
5466 AGG_HASHED,
5467 AGGSPLIT_SIMPLE,
5468 root->processed_distinctClause,
5469 NIL,
5470 NULL,
5471 numDistinctRows));
5472 }
5473
5475}
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition makefuncs.c:350
LimitPath * create_limit_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, Node *limitOffset, Node *limitCount, LimitOption limitOption, int64 offset_est, int64 count_est)
Definition pathnode.c:3793
UniquePath * create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, int numCols, double numGroups)
Definition pathnode.c:3005
static List * get_useful_pathkeys_for_distinct(PlannerInfo *root, List *needed_pathkeys, List *path_pathkeys)
Definition planner.c:5486
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
Definition selfuncs.c:3802
List * get_sortgrouplist_exprs(List *sgClauses, List *targetList)
Definition tlist.c:401
References add_path(), AGG_HASHED, AGGSPLIT_SIMPLE, Assert, create_agg_path(), create_limit_path(), create_unique_path(), enable_hashagg, estimate_num_groups(), fb(), foreach_node, get_sortgrouplist_exprs(), get_useful_pathkeys_for_distinct(), grouping_is_hashable(), grouping_is_sortable(), Int64GetDatum(), InvalidOid, lfirst, LIMIT_OPTION_COUNT, list_length(), make_ordered_path(), makeConst(), NIL, parse(), root, and Path::rows.
Referenced by create_distinct_paths(), and create_partial_distinct_paths().
◆ create_final_unique_paths()
|
static |
Definition at line 8932 of file planner.c.
8935{
8937
8938 /* Estimate number of output rows */
8940 sjinfo->semi_rhs_exprs,
8941 cheapest_input_path->rows,
8942 NULL,
8943 NULL);
8944
8945 /* Consider sort-based implementations, if possible. */
8947 {
8949
8950 /*
8951 * Use any available suitably-sorted path as input, and also consider
8952 * sorting the cheapest-total path and incremental sort on any paths
8953 * with presorted keys.
8954 *
8955 * To save planning time, we ignore parameterized input paths unless
8956 * they are the cheapest-total path.
8957 */
8959 {
8961 Path *path;
8963 int presorted_keys;
8964
8965 /*
8966 * Ignore parameterized paths that are not the cheapest-total
8967 * path.
8968 */
8971 continue;
8972
8974 input_path->pathkeys,
8975 &presorted_keys);
8976
8977 /*
8978 * Ignore paths that are not suitably or partially sorted, unless
8979 * they are the cheapest total path (no need to deal with paths
8980 * which have presorted keys when incremental sort is disabled).
8981 */
8983 (presorted_keys == 0 || !enable_incremental_sort))
8984 continue;
8985
8986 /*
8987 * Make a separate ProjectionPath in case we need a Result node.
8988 */
8990 unique_rel,
8991 input_path,
8992 unique_rel->reltarget);
8993
8995 {
8996 /*
8997 * We've no need to consider both a sort and incremental sort.
8998 * We'll just do a sort if there are no presorted keys and an
8999 * incremental sort when there are presorted keys.
9000 */
9003 unique_rel,
9004 path,
9005 sortPathkeys,
9006 -1.0);
9007 else
9009 unique_rel,
9010 path,
9011 sortPathkeys,
9012 presorted_keys,
9013 -1.0);
9014 }
9015
9018 unique_rel->rows);
9019
9020 add_path(unique_rel, path);
9021 }
9022 }
9023
9024 /* Consider hash-based implementation, if possible. */
9026 {
9027 Path *path;
9028
9029 /*
9030 * Make a separate ProjectionPath in case we need a Result node.
9031 */
9033 unique_rel,
9034 cheapest_input_path,
9035 unique_rel->reltarget);
9036
9038 unique_rel,
9039 path,
9040 cheapest_input_path->pathtarget,
9041 AGG_HASHED,
9042 AGGSPLIT_SIMPLE,
9043 groupClause,
9044 NIL,
9045 NULL,
9046 unique_rel->rows);
9047
9048 add_path(unique_rel, path);
9049 }
9050}
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:2855
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
Definition pathnode.c:2904
References add_path(), AGG_HASHED, AGGSPLIT_SIMPLE, create_agg_path(), create_incremental_sort_path(), create_projection_path(), create_sort_path(), create_unique_path(), enable_incremental_sort, estimate_num_groups(), fb(), lfirst, list_length(), NIL, pathkeys_count_contained_in(), RelOptInfo::reltarget, root, RelOptInfo::rows, SpecialJoinInfo::semi_can_btree, SpecialJoinInfo::semi_can_hash, and SpecialJoinInfo::semi_rhs_exprs.
Referenced by create_partial_unique_paths(), and create_unique_paths().
◆ create_grouping_paths()
|
static |
Definition at line 4050 of file planner.c.
4055{
4057 RelOptInfo *grouped_rel;
4060
4063
4064 /*
4065 * Create grouping relation to hold fully aggregated grouping and/or
4066 * aggregation paths.
4067 */
4069 target_parallel_safe, parse->havingQual);
4070
4071 /*
4072 * Create either paths for a degenerate grouping or paths for ordinary
4073 * grouping, as appropriate.
4074 */
4077 else
4078 {
4079 int flags = 0;
4080 GroupPathExtraData extra;
4081
4082 /*
4083 * Determine whether it's possible to perform sort-based
4084 * implementations of grouping. (Note that if processed_groupClause
4085 * is empty, grouping_is_sortable() is trivially true, and all the
4086 * pathkeys_contained_in() tests will succeed too, so that we'll
4087 * consider every surviving input path.)
4088 *
4089 * If we have grouping sets, we might be able to sort some but not all
4090 * of them; in this case, we need can_sort to be true as long as we
4091 * must consider any sorted-input plan.
4092 */
4095 flags |= GROUPING_CAN_USE_SORT;
4096
4097 /*
4098 * Determine whether we should consider hash-based implementations of
4099 * grouping.
4100 *
4101 * Hashed aggregation only applies if we're grouping. If we have
4102 * grouping sets, some groups might be hashable but others not; in
4103 * this case we set can_hash true as long as there is nothing globally
4104 * preventing us from hashing (and we should therefore consider plans
4105 * with hashes).
4106 *
4107 * Executor doesn't support hashed aggregation with DISTINCT or ORDER
4108 * BY aggregates. (Doing so would imply storing *all* the input
4109 * values in the hash table, and/or running many sorts in parallel,
4110 * either of which seems like a certain loser.) We similarly don't
4111 * support ordered-set aggregates in hashed aggregation, but that case
4112 * is also included in the numOrderedAggs count.
4113 *
4114 * Note: grouping_is_hashable() is much more expensive to check than
4115 * the other gating conditions, so we want to do it last.
4116 */
4118 root->numOrderedAggs == 0 &&
4120 flags |= GROUPING_CAN_USE_HASH;
4121
4122 /*
4123 * Determine whether partial aggregation is possible.
4124 */
4126 flags |= GROUPING_CAN_PARTIAL_AGG;
4127
4128 extra.flags = flags;
4129 extra.target_parallel_safe = target_parallel_safe;
4133
4134 /*
4135 * Determine whether partitionwise aggregation is in theory possible.
4136 * It can be disabled by the user, and for now, we don't try to
4137 * support grouping sets. create_ordinary_grouping_paths() will check
4138 * additional conditions, such as whether input_rel is partitioned.
4139 */
4142 else
4144
4147 &partially_grouped_rel);
4148 }
4149
4150 set_cheapest(grouped_rel);
4151 return grouped_rel;
4152}
static void create_degenerate_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel)
Definition planner.c:4240
static bool is_degenerate_grouping(PlannerInfo *root)
Definition planner.c:4219
static void create_ordinary_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, GroupPathExtraData *extra, RelOptInfo **partially_grouped_rel_p)
Definition planner.c:4303
static RelOptInfo * make_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, Node *havingQual)
Definition planner.c:4163
void get_agg_clause_costs(PlannerInfo *root, AggSplit aggsplit, AggClauseCosts *costs)
Definition prepagg.c:559
Definition pathnodes.h:3680
References AGGSPLIT_SIMPLE, can_partial_agg(), create_degenerate_grouping_paths(), create_ordinary_grouping_paths(), enable_partitionwise_aggregate, fb(), GroupPathExtraData::flags, get_agg_clause_costs(), GROUPING_CAN_PARTIAL_AGG, GROUPING_CAN_USE_HASH, GROUPING_CAN_USE_SORT, grouping_is_hashable(), grouping_is_sortable(), GroupPathExtraData::havingQual, is_degenerate_grouping(), make_grouping_rel(), MemSet, NIL, parse(), GroupPathExtraData::partial_costs_set, PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, GroupPathExtraData::patype, root, set_cheapest(), GroupPathExtraData::target_parallel_safe, and GroupPathExtraData::targetList.
Referenced by grouping_planner().
◆ create_one_window_path()
|
static |
Definition at line 4883 of file planner.c.
4890{
4892 ListCell *l;
4894
4895 /*
4896 * Since each window clause could require a different sort order, we stack
4897 * up a WindowAgg node for each clause, with sort steps between them as
4898 * needed. (We assume that select_active_windows chose a good order for
4899 * executing the clauses in.)
4900 *
4901 * input_target should contain all Vars and Aggs needed for the result.
4902 * (In some cases we wouldn't need to propagate all of these all the way
4903 * to the top, since they might only be needed as inputs to WindowFuncs.
4904 * It's probably not worth trying to optimize that though.) It must also
4905 * contain all window partitioning and sorting expressions, to ensure
4906 * they're computed only once at the bottom of the stack (that's critical
4907 * for volatile functions). As we climb up the stack, we'll add outputs
4908 * for the WindowFuncs computed at each level.
4909 */
4911
4912 foreach(l, activeWindows)
4913 {
4915 List *window_pathkeys;
4917 int presorted_keys;
4919 bool topwindow;
4921
4923 wc,
4924 root->processed_tlist);
4925
4927 path->pathkeys,
4928 &presorted_keys);
4929
4930 /* Sort if necessary */
4932 {
4933 /*
4934 * No presorted keys or incremental sort disabled, just perform a
4935 * complete sort.
4936 */
4939 path,
4940 window_pathkeys,
4941 -1.0);
4942 else
4943 {
4944 /*
4945 * Since we have presorted keys and incremental sort is
4946 * enabled, just use incremental sort.
4947 */
4949 window_rel,
4950 path,
4951 window_pathkeys,
4952 presorted_keys,
4953 -1.0);
4954 }
4955 }
4956
4958 {
4959 /*
4960 * Add the current WindowFuncs to the output target for this
4961 * intermediate WindowAggPath. We must copy window_target to
4962 * avoid changing the previous path's target.
4963 *
4964 * Note: a WindowFunc adds nothing to the target's eval costs; but
4965 * we do need to account for the increase in tlist width.
4966 */
4968
4971 {
4973
4976 }
4978 }
4979 else
4980 {
4981 /* Install the goal target in the topmost WindowAgg */
4983 }
4984
4985 /* mark the final item in the list as the top-level window */
4987
4988 /*
4989 * Collect the WindowFuncRunConditions from each WindowFunc and
4990 * convert them into OpExprs
4991 */
4993 {
4996
4998 {
5001 Expr *opexpr;
5004
5006 {
5009 }
5010 else
5011 {
5014 }
5015
5017 BOOLOID,
5018 false,
5019 leftop,
5020 rightop,
5021 InvalidOid,
5022 wfuncrc->inputcollid);
5023
5024 runcondition = lappend(runcondition, opexpr);
5025
5026 if (!topwindow)
5028 }
5029 }
5030
5031 path = (Path *)
5034 runcondition, wc,
5036 }
5037
5039}
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Definition makefuncs.c:701
WindowAggPath * create_windowagg_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *windowFuncs, List *runCondition, WindowClause *winclause, List *qual, bool topwindow)
Definition pathnode.c:3393
static List * make_pathkeys_for_window(PlannerInfo *root, WindowClause *wc, List *tlist)
Definition planner.c:6544
Definition parsenodes.h:1653
Definition primnodes.h:622
Definition primnodes.h:587
void add_column_to_pathtarget(PathTarget *target, Expr *expr, Index sortgroupref)
Definition tlist.c:704
References add_column_to_pathtarget(), add_path(), clamp_width_est(), copy_pathtarget(), copyObject, create_incremental_sort_path(), create_sort_path(), create_windowagg_path(), enable_incremental_sort, fb(), foreach_current_index, get_typavgwidth(), InvalidOid, lappend(), lfirst_node, list_length(), lnext(), make_opclause(), make_pathkeys_for_window(), NIL, Path::pathkeys, pathkeys_count_contained_in(), root, and WindowClause::winref.
Referenced by create_window_paths().
◆ create_ordered_paths()
|
static |
Definition at line 5571 of file planner.c.
5576{
5580
5581 /* For now, do all work in the (ORDERED, NULL) upperrel */
5583
5584 /*
5585 * If the input relation is not parallel-safe, then the ordered relation
5586 * can't be parallel-safe, either. Otherwise, it's parallel-safe if the
5587 * target list is parallel-safe.
5588 */
5591
5592 /* Assume that the same path generation strategies are allowed. */
5594
5595 /*
5596 * If the input rel belongs to a single FDW, so does the ordered_rel.
5597 */
5602
5604 {
5608 int presorted_keys;
5609
5611 input_path->pathkeys, &presorted_keys);
5612
5615 else
5616 {
5617 /*
5618 * Try at least sorting the cheapest path and also try
5619 * incrementally sorting any path which is partially sorted
5620 * already (no need to deal with paths which have presorted keys
5621 * when incremental sort is disabled unless it's the cheapest
5622 * input path).
5623 */
5625 (presorted_keys == 0 || !enable_incremental_sort))
5626 continue;
5627
5628 /*
5629 * We've no need to consider both a sort and incremental sort.
5630 * We'll just do a sort if there are no presorted keys and an
5631 * incremental sort when there are presorted keys.
5632 */
5635 ordered_rel,
5636 input_path,
5637 root->sort_pathkeys,
5638 limit_tuples);
5639 else
5641 ordered_rel,
5642 input_path,
5643 root->sort_pathkeys,
5644 presorted_keys,
5645 limit_tuples);
5646 }
5647
5648 /*
5649 * If the pathtarget of the result path has different expressions from
5650 * the target to be applied, a projection step is needed.
5651 */
5654 sorted_path, target);
5655
5657 }
5658
5659 /*
5660 * generate_gather_paths() will have already generated a simple Gather
5661 * path for the best parallel path, if any, and the loop above will have
5662 * considered sorting it. Similarly, generate_gather_paths() will also
5663 * have generated order-preserving Gather Merge plans which can be used
5664 * without sorting if they happen to match the sort_pathkeys, and the loop
5665 * above will have handled those as well. However, there's one more
5666 * possibility: it may make sense to sort the cheapest partial path or
5667 * incrementally sort any partial path that is partially sorted according
5668 * to the required output order and then use Gather Merge.
5669 */
5672 {
5674
5676
5678 {
5682 int presorted_keys;
5684
5686 input_path->pathkeys,
5687 &presorted_keys);
5688
5690 continue;
5691
5692 /*
5693 * Try at least sorting the cheapest path and also try
5694 * incrementally sorting any path which is partially sorted
5695 * already (no need to deal with paths which have presorted keys
5696 * when incremental sort is disabled unless it's the cheapest
5697 * partial path).
5698 */
5700 (presorted_keys == 0 || !enable_incremental_sort))
5701 continue;
5702
5703 /*
5704 * We've no need to consider both a sort and incremental sort.
5705 * We'll just do a sort if there are no presorted keys and an
5706 * incremental sort when there are presorted keys.
5707 */
5710 ordered_rel,
5711 input_path,
5712 root->sort_pathkeys,
5713 limit_tuples);
5714 else
5716 ordered_rel,
5717 input_path,
5718 root->sort_pathkeys,
5719 presorted_keys,
5720 limit_tuples);
5724 sorted_path,
5725 sorted_path->pathtarget,
5727 &total_groups);
5728
5729 /*
5730 * If the pathtarget of the result path has different expressions
5731 * from the target to be applied, a projection step is needed.
5732 */
5735 sorted_path, target);
5736
5738 }
5739 }
5740
5741 /*
5742 * If there is an FDW that's responsible for all baserels of the query,
5743 * let it consider adding ForeignPaths.
5744 */
5746 ordered_rel->fdwroutine->GetForeignUpperPaths)
5749 NULL);
5750
5751 /* Let extensions possibly add some more paths */
5755
5756 /*
5757 * No need to bother with set_cheapest here; grouping_planner does not
5758 * need us to do it.
5759 */
5761
5763}
GatherMergePath * create_gather_merge_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
Definition pathnode.c:1813
References add_path(), apply_projection_to_path(), Assert, compute_gather_rows(), create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), create_upper_paths_hook, enable_incremental_sort, equal(), PathTarget::exprs, fb(), fetch_upper_rel(), lfirst, linitial, NIL, pathkeys_count_contained_in(), root, and UPPERREL_ORDERED.
Referenced by grouping_planner().
◆ create_ordinary_grouping_paths()
|
static |
Definition at line 4303 of file planner.c.
4309{
4312
4313 /*
4314 * If this is the topmost grouping relation or if the parent relation is
4315 * doing some form of partitionwise aggregation, then we may be able to do
4316 * it at this level also. However, if the input relation is not
4317 * partitioned, partitionwise aggregate is impossible.
4318 */
4321 {
4322 /*
4323 * If this is the topmost relation or if the parent relation is doing
4324 * full partitionwise aggregation, then we can do full partitionwise
4325 * aggregation provided that the GROUP BY clause contains all of the
4326 * partitioning columns at this level and the collation used by GROUP
4327 * BY matches the partitioning collation. Otherwise, we can do at
4328 * most partial partitionwise aggregation. But if partial aggregation
4329 * is not supported in general then we can't use it for partitionwise
4330 * aggregation either.
4331 *
4332 * Check parse->groupClause not processed_groupClause, because it's
4333 * okay if some of the partitioning columns were proved redundant.
4334 */
4337 root->parse->groupClause))
4338 patype = PARTITIONWISE_AGGREGATE_FULL;
4340 patype = PARTITIONWISE_AGGREGATE_PARTIAL;
4341 else
4342 patype = PARTITIONWISE_AGGREGATE_NONE;
4343 }
4344
4345 /*
4346 * Before generating paths for grouped_rel, we first generate any possible
4347 * partially grouped paths; that way, later code can easily consider both
4348 * parallel and non-parallel approaches to grouping.
4349 */
4351 {
4353
4354 /*
4355 * If we're doing partitionwise aggregation at this level, force
4356 * creation of a partially_grouped_rel so we can add partitionwise
4357 * paths to it.
4358 */
4360
4361 partially_grouped_rel =
4363 grouped_rel,
4364 input_rel,
4365 gd,
4366 extra,
4367 force_rel_creation);
4368 }
4369
4370 /* Set out parameter. */
4372
4373 /* Apply partitionwise aggregation technique, if possible. */
4377 gd, patype, extra);
4378
4379 /* If we are doing partial aggregation only, return. */
4381 {
4383
4386
4387 return;
4388 }
4389
4390 /* Gather any partially grouped partial paths. */
4393
4394 /* Now choose the best path(s) for partially_grouped_rel. */
4397
4398 /* Build final grouping paths */
4401 extra);
4402
4403 /* Give a helpful error if we failed to find any implementation */
4409
4410 /*
4411 * If there is an FDW that's responsible for all baserels of the query,
4412 * let it consider adding ForeignPaths.
4413 */
4414 if (grouped_rel->fdwroutine &&
4415 grouped_rel->fdwroutine->GetForeignUpperPaths)
4417 input_rel, grouped_rel,
4418 extra);
4419
4420 /* Let extensions possibly add some more paths */
4423 input_rel, grouped_rel,
4424 extra);
4425}
static void add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, RelOptInfo *partially_grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, GroupPathExtraData *extra)
Definition planner.c:7345
static RelOptInfo * create_partial_grouping_paths(PlannerInfo *root, RelOptInfo *grouped_rel, RelOptInfo *input_rel, grouping_sets_data *gd, GroupPathExtraData *extra, bool force_rel_creation)
Definition planner.c:7606
static void create_partitionwise_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, RelOptInfo *partially_grouped_rel, const AggClauseCosts *agg_costs, grouping_sets_data *gd, PartitionwiseAggregateType patype, GroupPathExtraData *extra)
Definition planner.c:8383
static bool group_by_has_partkey(RelOptInfo *input_rel, List *targetList, List *groupClause)
Definition planner.c:8520
References add_paths_to_grouping_rel(), Assert, create_partial_grouping_paths(), create_partitionwise_grouping_paths(), create_upper_paths_hook, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), GroupPathExtraData::flags, gather_grouping_paths(), group_by_has_partkey(), GROUPING_CAN_PARTIAL_AGG, IS_PARTITIONED_REL, NIL, PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, PARTITIONWISE_AGGREGATE_PARTIAL, RelOptInfo::pathlist, GroupPathExtraData::patype, root, set_cheapest(), GroupPathExtraData::targetList, and UPPERREL_GROUP_AGG.
Referenced by create_grouping_paths(), and create_partitionwise_grouping_paths().
◆ create_partial_distinct_paths()
|
static |
Definition at line 5123 of file planner.c.
5126{
5133
5134 /* nothing to do when there are no partial paths in the input rel */
5136 return;
5137
5139
5140 /* can't do parallel DISTINCT ON */
5142 return;
5143
5145 NULL);
5146 partial_distinct_rel->reltarget = target;
5148
5149 /*
5150 * If input_rel belongs to a single FDW, so does the partial_distinct_rel.
5151 */
5156
5158
5160 parse->targetList);
5161
5162 /* estimate how many distinct rows we'll get from each worker */
5164 cheapest_partial_path->rows,
5166
5167 /*
5168 * Try sorting the cheapest path and incrementally sorting any paths with
5169 * presorted keys and put a unique paths atop of those. We'll also
5170 * attempt to reorder the required pathkeys to match the input path's
5171 * pathkeys as much as possible, in hopes of avoiding a possible need to
5172 * re-sort.
5173 */
5175 {
5177 {
5181
5182 useful_pathkeys_list =
5184 root->distinct_pathkeys,
5185 input_path->pathkeys);
5187
5189 {
5191 partial_distinct_rel,
5192 input_path,
5193 cheapest_partial_path,
5194 useful_pathkeys,
5195 -1.0);
5196
5198 continue;
5199
5200 /*
5201 * An empty distinct_pathkeys means all tuples have the same
5202 * value for the DISTINCT clause. See
5203 * create_final_distinct_paths()
5204 */
5206 {
5207 Node *limitCount;
5208
5212 true);
5213
5214 /*
5215 * Apply a LimitPath onto the partial path to restrict the
5216 * tuples from each worker to 1.
5217 * create_final_distinct_paths will need to apply an
5218 * additional LimitPath to restrict this to a single row
5219 * after the Gather node. If the query already has a
5220 * LIMIT clause, then we could end up with three Limit
5221 * nodes in the final plan. Consolidating the top two of
5222 * these could be done, but does not seem worth troubling
5223 * over.
5224 */
5227 sorted_path,
5228 NULL,
5229 limitCount,
5230 LIMIT_OPTION_COUNT,
5231 0, 1));
5232 }
5233 else
5234 {
5237 sorted_path,
5239 numDistinctRows));
5240 }
5241 }
5242 }
5243 }
5244
5245 /*
5246 * Now try hash aggregate paths, if enabled and hashing is possible. Since
5247 * we're not on the hook to ensure we do our best to create at least one
5248 * path here, we treat enable_hashagg as a hard off-switch rather than the
5249 * slightly softer variant in create_final_distinct_paths.
5250 */
5252 {
5255 partial_distinct_rel,
5256 cheapest_partial_path,
5257 cheapest_partial_path->pathtarget,
5258 AGG_HASHED,
5259 AGGSPLIT_SIMPLE,
5260 root->processed_distinctClause,
5261 NIL,
5262 NULL,
5263 numDistinctRows));
5264 }
5265
5266 /*
5267 * If there is an FDW that's responsible for all baserels of the query,
5268 * let it consider adding ForeignPaths.
5269 */
5271 partial_distinct_rel->fdwroutine->GetForeignUpperPaths)
5274 input_rel,
5275 partial_distinct_rel,
5276 NULL);
5277
5278 /* Let extensions possibly add some more partial paths */
5282
5284 {
5287
5288 /*
5289 * Finally, create paths to distinctify the final result. This step
5290 * is needed to remove any duplicates due to combining rows from
5291 * parallel workers.
5292 */
5294 final_distinct_rel);
5295 }
5296}
void add_partial_path(RelOptInfo *parent_rel, Path *new_path)
Definition pathnode.c:793
References add_partial_path(), AGG_HASHED, AGGSPLIT_SIMPLE, Assert, create_agg_path(), create_final_distinct_paths(), create_limit_path(), create_unique_path(), create_upper_paths_hook, enable_hashagg, estimate_num_groups(), fb(), fetch_upper_rel(), foreach_node, generate_useful_gather_paths(), get_sortgrouplist_exprs(), get_useful_pathkeys_for_distinct(), grouping_is_hashable(), grouping_is_sortable(), Int64GetDatum(), InvalidOid, lfirst, LIMIT_OPTION_COUNT, linitial, list_length(), make_ordered_path(), makeConst(), NIL, parse(), root, set_cheapest(), and UPPERREL_PARTIAL_DISTINCT.
Referenced by create_distinct_paths().
◆ create_partial_grouping_paths()
|
static |
Definition at line 7606 of file planner.c.
7612{
7625
7626 /*
7627 * Check whether any partially aggregated paths have been generated
7628 * through eager aggregation.
7629 */
7634
7635 /*
7636 * Consider whether we should generate partially aggregated non-partial
7637 * paths. We can only do this if we have a non-partial path, and only if
7638 * the parent of the input rel is performing partial partitionwise
7639 * aggregation. (Note that extra->patype is the type of partitionwise
7640 * aggregation being used at the parent level, not this level.)
7641 */
7644 cheapest_total_path = input_rel->cheapest_total_path;
7645
7646 /*
7647 * If parallelism is possible for grouped_rel, then we should consider
7648 * generating partially-grouped partial paths. However, if the input rel
7649 * has no partial paths, then we can't.
7650 */
7653
7654 /*
7655 * If we can't partially aggregate partial paths, and we can't partially
7656 * aggregate non-partial paths, and no partially aggregated paths were
7657 * generated by eager aggregation, then don't bother creating the new
7658 * RelOptInfo at all, unless the caller specified force_rel_creation.
7659 */
7663 !force_rel_creation)
7665
7666 /*
7667 * Build a new upper relation to represent the result of partially
7668 * aggregating the rows from the input relation.
7669 */
7672 grouped_rel->relids);
7673 partially_grouped_rel->consider_parallel =
7674 grouped_rel->consider_parallel;
7680 partially_grouped_rel->fdwroutine = grouped_rel->fdwroutine;
7681
7682 /*
7683 * Build target list for partial aggregate paths. These paths cannot just
7684 * emit the same tlist as regular aggregate paths, because (1) we must
7685 * include Vars and Aggrefs needed in HAVING, which might not appear in
7686 * the result tlist, and (2) the Aggrefs must be set in partial mode.
7687 */
7690 extra->havingQual);
7691
7693 {
7694 /*
7695 * Collect statistics about aggregates for estimating costs of
7696 * performing aggregation in parallel.
7697 */
7701 {
7702 /* partial phase */
7704 agg_partial_costs);
7705
7706 /* final phase */
7708 agg_final_costs);
7709 }
7710
7712 }
7713
7714 /* Estimate number of partial groups. */
7716 dNumPartialGroups =
7718 cheapest_total_path->rows,
7719 gd,
7720 extra->targetList);
7722 dNumPartialPartialGroups =
7724 cheapest_partial_path->rows,
7725 gd,
7726 extra->targetList);
7727
7729 {
7730 /* This should have been checked previously */
7732
7733 /*
7734 * Use any available suitably-sorted path as input, and also consider
7735 * sorting the cheapest partial path.
7736 */
7738 {
7743
7744 /* generate alternative group orderings that might be useful */
7746
7748
7749 /* process all potentially interesting grouping reorderings */
7751 {
7753
7754 /* restore the path (we replace it in the loop) */
7755 path = path_save;
7756
7758 partially_grouped_rel,
7759 path,
7760 cheapest_total_path,
7761 info->pathkeys,
7762 -1.0);
7763
7765 continue;
7766
7770 partially_grouped_rel,
7771 path,
7772 partially_grouped_rel->reltarget,
7774 AGGSPLIT_INITIAL_SERIAL,
7775 info->clauses,
7776 NIL,
7777 agg_partial_costs,
7778 dNumPartialGroups));
7779 else
7782 partially_grouped_rel,
7783 path,
7784 info->clauses,
7785 NIL,
7786 dNumPartialGroups));
7787 }
7788 }
7789 }
7790
7792 {
7793 /* Similar to above logic, but for partial paths. */
7795 {
7800
7801 /* generate alternative group orderings that might be useful */
7803
7805
7806 /* process all potentially interesting grouping reorderings */
7808 {
7810
7811
7812 /* restore the path (we replace it in the loop) */
7813 path = path_save;
7814
7816 partially_grouped_rel,
7817 path,
7818 cheapest_partial_path,
7819 info->pathkeys,
7820 -1.0);
7821
7823 continue;
7824
7828 partially_grouped_rel,
7829 path,
7830 partially_grouped_rel->reltarget,
7832 AGGSPLIT_INITIAL_SERIAL,
7833 info->clauses,
7834 NIL,
7835 agg_partial_costs,
7836 dNumPartialPartialGroups));
7837 else
7840 partially_grouped_rel,
7841 path,
7842 info->clauses,
7843 NIL,
7844 dNumPartialPartialGroups));
7845 }
7846 }
7847 }
7848
7849 /*
7850 * Add a partially-grouped HashAgg Path where possible
7851 */
7853 {
7854 /* Checked above */
7856
7859 partially_grouped_rel,
7860 cheapest_total_path,
7861 partially_grouped_rel->reltarget,
7862 AGG_HASHED,
7863 AGGSPLIT_INITIAL_SERIAL,
7864 root->processed_groupClause,
7865 NIL,
7866 agg_partial_costs,
7867 dNumPartialGroups));
7868 }
7869
7870 /*
7871 * Now add a partially-grouped HashAgg partial Path where possible
7872 */
7874 {
7877 partially_grouped_rel,
7878 cheapest_partial_path,
7879 partially_grouped_rel->reltarget,
7880 AGG_HASHED,
7881 AGGSPLIT_INITIAL_SERIAL,
7882 root->processed_groupClause,
7883 NIL,
7884 agg_partial_costs,
7885 dNumPartialPartialGroups));
7886 }
7887
7888 /*
7889 * Add any partially aggregated paths generated by eager aggregation to
7890 * the new upper relation after applying projection steps as needed.
7891 */
7893 {
7894 /* Add the paths */
7896 {
7898
7899 /* Shouldn't have any parameterized paths anymore */
7901
7903 partially_grouped_rel,
7904 path,
7905 partially_grouped_rel->reltarget);
7906
7908 }
7909
7910 /*
7911 * Likewise add the partial paths, but only if parallelism is possible
7912 * for partially_grouped_rel.
7913 */
7915 {
7917 {
7919
7920 /* Shouldn't have any parameterized paths anymore */
7922
7924 partially_grouped_rel,
7925 path,
7926 partially_grouped_rel->reltarget);
7927
7929 }
7930 }
7931 }
7932
7933 /*
7934 * If there is an FDW that's responsible for all baserels of the query,
7935 * let it consider adding partially grouped ForeignPaths.
7936 */
7938 partially_grouped_rel->fdwroutine->GetForeignUpperPaths)
7939 {
7941
7945 extra);
7946 }
7947
7949}
static PathTarget * make_partial_grouping_target(PlannerInfo *root, PathTarget *grouping_target, Node *havingQual)
Definition planner.c:5906
Definition fdwapi.h:209
GetForeignUpperPaths_function GetForeignUpperPaths
Definition fdwapi.h:230
References add_partial_path(), add_path(), GroupPathExtraData::agg_final_costs, AGG_HASHED, GroupPathExtraData::agg_partial_costs, AGG_PLAIN, AGG_SORTED, AGGSPLIT_FINAL_DESERIAL, AGGSPLIT_INITIAL_SERIAL, Assert, GroupByOrdering::clauses, RelOptInfo::consider_parallel, create_agg_path(), create_group_path(), create_projection_path(), fb(), fetch_upper_rel(), GroupPathExtraData::flags, get_agg_clause_costs(), get_number_of_groups(), get_useful_group_keys_orderings(), FdwRoutine::GetForeignUpperPaths, GROUPING_CAN_USE_HASH, GROUPING_CAN_USE_SORT, GroupPathExtraData::havingQual, IS_DUMMY_REL, lfirst, linitial, list_length(), make_ordered_path(), make_partial_grouping_target(), MemSet, NIL, parse(), GroupPathExtraData::partial_costs_set, PARTITIONWISE_AGGREGATE_PARTIAL, GroupByOrdering::pathkeys, GroupPathExtraData::patype, RelOptInfo::pgs_mask, RelOptInfo::relids, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, Path::rows, RelOptInfo::serverid, GroupPathExtraData::targetList, UPPERREL_PARTIAL_GROUP_AGG, RelOptInfo::userid, and RelOptInfo::useridiscurrent.
Referenced by create_ordinary_grouping_paths().
◆ create_partial_unique_paths()
|
static |
Definition at line 9057 of file planner.c.
9060{
9063
9064 /* nothing to do when there are no partial paths in the input rel */
9066 return;
9067
9068 /*
9069 * nothing to do if there's anything in the targetlist that's
9070 * parallel-restricted.
9071 */
9073 return;
9074
9076
9079
9080 /*
9081 * clear path info
9082 */
9089
9090 /* Estimate number of output rows */
9092 sjinfo->semi_rhs_exprs,
9093 cheapest_partial_path->rows,
9094 NULL,
9095 NULL);
9097
9098 /* Consider sort-based implementations, if possible. */
9100 {
9102
9103 /*
9104 * Use any available suitably-sorted path as input, and also consider
9105 * sorting the cheapest partial path and incremental sort on any paths
9106 * with presorted keys.
9107 */
9109 {
9111 Path *path;
9113 int presorted_keys;
9114
9116 input_path->pathkeys,
9117 &presorted_keys);
9118
9119 /*
9120 * Ignore paths that are not suitably or partially sorted, unless
9121 * they are the cheapest partial path (no need to deal with paths
9122 * which have presorted keys when incremental sort is disabled).
9123 */
9125 (presorted_keys == 0 || !enable_incremental_sort))
9126 continue;
9127
9128 /*
9129 * Make a separate ProjectionPath in case we need a Result node.
9130 */
9132 partial_unique_rel,
9133 input_path,
9134 partial_unique_rel->reltarget);
9135
9137 {
9138 /*
9139 * We've no need to consider both a sort and incremental sort.
9140 * We'll just do a sort if there are no presorted keys and an
9141 * incremental sort when there are presorted keys.
9142 */
9145 partial_unique_rel,
9146 path,
9147 sortPathkeys,
9148 -1.0);
9149 else
9151 partial_unique_rel,
9152 path,
9153 sortPathkeys,
9154 presorted_keys,
9155 -1.0);
9156 }
9157
9160 partial_unique_rel->rows);
9161
9163 }
9164 }
9165
9166 /* Consider hash-based implementation, if possible. */
9168 {
9169 Path *path;
9170
9171 /*
9172 * Make a separate ProjectionPath in case we need a Result node.
9173 */
9175 partial_unique_rel,
9176 cheapest_partial_path,
9177 partial_unique_rel->reltarget);
9178
9180 partial_unique_rel,
9181 path,
9182 cheapest_partial_path->pathtarget,
9183 AGG_HASHED,
9184 AGGSPLIT_SIMPLE,
9185 groupClause,
9186 NIL,
9187 NULL,
9188 partial_unique_rel->rows);
9189
9191 }
9192
9194 {
9197
9198 /*
9199 * Finally, create paths to unique-ify the final result. This step is
9200 * needed to remove any duplicates due to combining rows from parallel
9201 * workers.
9202 */
9204 sortPathkeys, groupClause,
9205 sjinfo, unique_rel);
9206 }
9207}
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets))
static void create_final_unique_paths(PlannerInfo *root, RelOptInfo *input_rel, List *sortPathkeys, List *groupClause, SpecialJoinInfo *sjinfo, RelOptInfo *unique_rel)
Definition planner.c:8932
References add_partial_path(), AGG_HASHED, AGGSPLIT_SIMPLE, create_agg_path(), create_final_unique_paths(), create_incremental_sort_path(), create_projection_path(), create_sort_path(), create_unique_path(), enable_incremental_sort, estimate_num_groups(), PathTarget::exprs, fb(), generate_useful_gather_paths(), is_parallel_safe(), lfirst, linitial, list_length(), makeNode, memcpy(), NIL, pathkeys_count_contained_in(), RelOptInfo::reltarget, root, Path::rows, SpecialJoinInfo::semi_can_btree, SpecialJoinInfo::semi_can_hash, SpecialJoinInfo::semi_rhs_exprs, and set_cheapest().
Referenced by create_unique_paths().
◆ create_partitionwise_grouping_paths()
|
static |
Definition at line 8383 of file planner.c.
8391{
8397
8401
8402 /* Add paths for partitionwise aggregation/grouping. */
8403 i = -1;
8405 {
8408 AppendRelInfo **appinfos;
8409 int nappinfos;
8413
8415
8416 /* Dummy children can be ignored. */
8418 continue;
8419
8421
8422 /*
8423 * Copy the given "extra" structure as is and then override the
8424 * members specific to this child.
8425 */
8427
8429 &nappinfos);
8430
8434 nappinfos, appinfos);
8435
8436 /* Translate havingQual and targetList. */
8439 extra->havingQual,
8440 nappinfos, appinfos);
8444 nappinfos, appinfos);
8445
8446 /*
8447 * extra->patype was the value computed for our parent rel; patype is
8448 * the value for this relation. For the child, our value is its
8449 * parent rel's value.
8450 */
8451 child_extra.patype = patype;
8452
8453 /*
8454 * Create grouping relation to hold fully aggregated grouping and/or
8455 * aggregation paths for the child.
8456 */
8458 child_target,
8459 extra->target_parallel_safe,
8460 child_extra.havingQual);
8461
8462 /* Create grouping paths for this child relation. */
8464 child_grouped_rel,
8466 &child_partially_grouped_rel);
8467
8469 {
8472 child_partially_grouped_rel);
8473 }
8474 else
8476
8478 {
8481 child_grouped_rel);
8482 }
8483
8484 pfree(appinfos);
8485 }
8486
8487 /*
8488 * Try to create append paths for partially grouped children. For full
8489 * partitionwise aggregation, we might have paths in the partial_pathlist
8490 * if parallel aggregation is possible. For partial partitionwise
8491 * aggregation, we may have paths in both pathlist and partial_pathlist.
8492 *
8493 * NB: We must have a partially grouped path for every child in order to
8494 * generate a partially grouped path for this relation.
8495 */
8497 {
8499
8502 }
8503
8504 /* If possible, create append paths for fully grouped children. */
8506 {
8508
8510 }
8511}
References add_paths_to_append_rel(), adjust_appendrel_attrs(), Assert, bms_next_member(), copy_pathtarget(), create_ordinary_grouping_paths(), PathTarget::exprs, fb(), find_appinfos_by_relids(), GroupPathExtraData::havingQual, i, IS_DUMMY_REL, lappend(), make_grouping_rel(), memcpy(), NIL, PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, PARTITIONWISE_AGGREGATE_PARTIAL, pfree(), RelOptInfo::reltarget, root, set_cheapest(), GroupPathExtraData::target_parallel_safe, and GroupPathExtraData::targetList.
Referenced by create_ordinary_grouping_paths().
◆ create_unique_paths()
| RelOptInfo * create_unique_paths | ( | PlannerInfo * | root, |
| RelOptInfo * | rel, | ||
| SpecialJoinInfo * | sjinfo | ||
| ) |
Definition at line 8663 of file planner.c.
8664{
8665 RelOptInfo *unique_rel;
8668 MemoryContext oldcontext;
8669
8670 /* Caller made a mistake if SpecialJoinInfo is the wrong one */
8673
8674 /* If result already cached, return it */
8677
8678 /* If it's not possible to unique-ify, return NULL */
8681
8682 /*
8683 * Punt if this is a child relation and we failed to build a unique-ified
8684 * relation for its parent. This can happen if all the RHS columns were
8685 * found to be equated to constants when unique-ifying the parent table,
8686 * leaving no columns to unique-ify.
8687 */
8690
8691 /*
8692 * When called during GEQO join planning, we are in a short-lived memory
8693 * context. We must make sure that the unique rel and any subsidiary data
8694 * structures created for a baserel survive the GEQO cycle, else the
8695 * baserel is trashed for future GEQO cycles. On the other hand, when we
8696 * are creating those for a joinrel during GEQO, we don't want them to
8697 * clutter the main planning context. Upshot is that the best solution is
8698 * to explicitly allocate memory in the same context the given RelOptInfo
8699 * is in.
8700 */
8702
8705
8706 /*
8707 * clear path info
8708 */
8715
8716 /*
8717 * Build the target list for the unique rel. We also build the pathkeys
8718 * that represent the ordering requirements for the sort-based
8719 * implementation, and the list of SortGroupClause nodes that represent
8720 * the columns to be grouped on for the hash-based implementation.
8721 *
8722 * For a child rel, we can construct these fields from those of its
8723 * parent.
8724 */
8726 {
8729
8731
8733
8734 /* Translate the target expressions */
8738 rel,
8739 rel->top_parent);
8740
8742
8744 groupClause = rel->top_parent->unique_groupclause;
8745 }
8746 else
8747 {
8753
8754 /*
8755 * The values we are supposed to unique-ify may be expressions in the
8756 * variables of the input rel's targetlist. We have to add any such
8757 * expressions to the unique rel's targetlist.
8758 *
8759 * To complicate matters, some of the values to be unique-ified may be
8760 * known redundant by the EquivalenceClass machinery (e.g., because
8761 * they have been equated to constants). There is no need to compare
8762 * such values during unique-ification, and indeed we had better not
8763 * try because the Vars involved may not have propagated as high as
8764 * the semijoin's level. We use make_pathkeys_for_sortclauses to
8765 * detect such cases, which is a tad inefficient but it doesn't seem
8766 * worth building specialized infrastructure for this.
8767 */
8770
8772 {
8775 Oid sortop;
8778
8781 {
8783 nextresno,
8784 NULL,
8785 false);
8787 nextresno++;
8789 }
8790
8791 /*
8792 * Try to build an ORDER BY list to sort the input compatibly. We
8793 * do this for each sortable clause even when the clauses are not
8794 * all sortable, so that we can detect clauses that are redundant
8795 * according to the pathkey machinery.
8796 */
8799 {
8800 Oid eqop;
8802
8803 /*
8804 * The Unique node will need equality operators. Normally
8805 * these are the same as the IN clause operators, but if those
8806 * are cross-type operators then the equality operators are
8807 * the ones for the IN clause operators' RHS datatype.
8808 */
8812 sortop);
8813
8816 sortcl->eqop = eqop;
8817 sortcl->sortop = sortop;
8822
8823 /*
8824 * At each step, convert the SortGroupClause list to pathkey
8825 * form. If the just-added SortGroupClause is redundant, the
8826 * result will be shorter than the SortGroupClause list.
8827 */
8829 newtlist);
8831 {
8832 /* Drop the redundant SortGroupClause */
8835 /* Undo tlist addition, if we made one */
8837 {
8839 nextresno--;
8840 }
8841 /* We need not consider this clause for hashing, either */
8842 continue;
8843 }
8844 }
8847 in_oper);
8848
8850 {
8851 /* Create a GROUP BY list for the Agg node to use */
8854
8855 /*
8856 * Get the hashable equality operators for the Agg node to
8857 * use. Normally these are the same as the IN clause
8858 * operators, but if those are cross-type operators then the
8859 * equality operators are the ones for the IN clause
8860 * operators' RHS datatype.
8861 */
8864 in_oper);
8865
8869 groupcl->sortop = sortop;
8874 }
8875 }
8876
8877 /*
8878 * Done building the sortPathkeys and groupClause. But the
8879 * sortPathkeys are bogus if not all the clauses were sortable.
8880 */
8883
8884 /*
8885 * It can happen that all the RHS columns are equated to constants.
8886 * We'd have to do something special to unique-ify in that case, and
8887 * it's such an unlikely-in-the-real-world case that it's not worth
8888 * the effort. So just punt if we found no columns to unique-ify.
8889 */
8891 {
8892 MemoryContextSwitchTo(oldcontext);
8894 }
8895
8896 /* Convert the required targetlist back to PathTarget form */
8898 }
8899
8900 /* build unique paths based on input rel's pathlist */
8902 sjinfo, unique_rel);
8903
8904 /* build unique paths based on input rel's partial_pathlist */
8906 sjinfo, unique_rel);
8907
8908 /* Now choose the best path(s) */
8909 set_cheapest(unique_rel);
8910
8911 /*
8912 * There shouldn't be any partial paths for the unique relation;
8913 * otherwise, we won't be able to properly guarantee uniqueness.
8914 */
8916
8917 /* Cache the result */
8918 rel->unique_rel = unique_rel;
8920 rel->unique_groupclause = groupClause;
8921
8922 MemoryContextSwitchTo(oldcontext);
8923
8924 return unique_rel;
8925}
Node * adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, RelOptInfo *childrel, RelOptInfo *parentrel)
Definition appendinfo.c:597
bool get_compatible_hash_operators(Oid opno, Oid *lhs_opno, Oid *rhs_opno)
Definition lsyscache.c:483
Oid get_equality_op_for_ordering_op(Oid opno, bool *reverse)
Definition lsyscache.c:326
Oid get_ordering_op_for_equality_op(Oid opno, bool use_lhs_type)
Definition lsyscache.c:364
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition makefuncs.c:289
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:138
Index assignSortGroupRef(TargetEntry *tle, List *tlist)
Definition parse_clause.c:3812
static void create_partial_unique_paths(PlannerInfo *root, RelOptInfo *input_rel, List *sortPathkeys, List *groupClause, SpecialJoinInfo *sjinfo, RelOptInfo *unique_rel)
Definition planner.c:9057
Definition memnodes.h:118
List * cheapest_parameterized_paths
Definition pathnodes.h:1055
List * make_tlist_from_pathtarget(PathTarget *target)
Definition tlist.c:633
References adjust_appendrel_attrs_multilevel(), Assert, assignSortGroupRef(), bms_equal(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, copy_pathtarget(), create_final_unique_paths(), create_partial_unique_paths(), create_pathtarget, elog, ERROR, fb(), forboth, get_compatible_hash_operators(), get_equality_op_for_ordering_op(), get_ordering_op_for_equality_op(), GetMemoryChunkContext(), IS_OTHER_REL, JOIN_SEMI, SpecialJoinInfo::jointype, lappend(), lfirst, lfirst_oid, list_delete_last(), list_length(), make_pathkeys_for_sortclauses(), make_tlist_from_pathtarget(), makeNode, makeTargetEntry(), memcpy(), MemoryContextSwitchTo(), NIL, OidIsValid, RelOptInfo::partial_pathlist, RelOptInfo::pathlist, RelOptInfo::ppilist, RelOptInfo::relids, RelOptInfo::reltarget, root, SpecialJoinInfo::semi_can_btree, SpecialJoinInfo::semi_can_hash, SpecialJoinInfo::semi_operators, SpecialJoinInfo::semi_rhs_exprs, set_cheapest(), SpecialJoinInfo::syn_righthand, tlist_member(), RelOptInfo::unique_groupclause, RelOptInfo::unique_pathkeys, and RelOptInfo::unique_rel.
Referenced by join_is_legal(), and populate_joinrel_with_paths().
◆ create_window_paths()
|
static |
Definition at line 4796 of file planner.c.
4803{
4806
4807 /* For now, do all work in the (WINDOW, NULL) upperrel */
4809
4810 /*
4811 * If the input relation is not parallel-safe, then the window relation
4812 * can't be parallel-safe, either. Otherwise, we need to examine the
4813 * target list and active windows for non-parallel-safe constructs.
4814 */
4818
4819 /*
4820 * If the input rel belongs to a single FDW, so does the window rel.
4821 */
4826
4827 /*
4828 * Consider computing window functions starting from the existing
4829 * cheapest-total path (which will likely require a sort) as well as any
4830 * existing paths that satisfy or partially satisfy root->window_pathkeys.
4831 */
4833 {
4835 int presorted_keys;
4836
4839 &presorted_keys) ||
4840 presorted_keys > 0)
4842 window_rel,
4843 path,
4844 input_target,
4845 output_target,
4846 wflists,
4847 activeWindows);
4848 }
4849
4850 /*
4851 * If there is an FDW that's responsible for all baserels of the query,
4852 * let it consider adding ForeignPaths.
4853 */
4855 window_rel->fdwroutine->GetForeignUpperPaths)
4858 NULL);
4859
4860 /* Let extensions possibly add some more paths */
4864
4865 /* Now choose the best path(s) */
4867
4869}
static void create_one_window_path(PlannerInfo *root, RelOptInfo *window_rel, Path *path, PathTarget *input_target, PathTarget *output_target, WindowFuncLists *wflists, List *activeWindows)
Definition planner.c:4883
References create_one_window_path(), create_upper_paths_hook, fb(), fetch_upper_rel(), is_parallel_safe(), lfirst, Path::pathkeys, pathkeys_count_contained_in(), root, set_cheapest(), and UPPERREL_WINDOW.
Referenced by grouping_planner().
◆ expression_planner()
Definition at line 7010 of file planner.c.
7011{
7013
7014 /*
7015 * Convert named-argument function calls, insert default arguments and
7016 * simplify constant subexprs
7017 */
7019
7020 /* Fill in opfuncid values if missing */
7022
7024}
Node * eval_const_expressions(PlannerInfo *root, Node *node)
Definition clauses.c:2516
References eval_const_expressions(), fb(), fix_opfuncids(), and result.
Referenced by ATExecAddColumn(), ATExecSetExpression(), ATPrepAlterColumnType(), BeginCopyFrom(), ComputePartitionAttrs(), contain_mutable_functions_after_planning(), contain_volatile_functions_after_planning(), createTableConstraints(), ExecPrepareCheck(), ExecPrepareExpr(), ExecPrepareQual(), load_domaintype_info(), set_baserel_partition_constraint(), slot_fill_defaults(), and transformPartitionBoundValue().
◆ expression_planner_with_deps()
Definition at line 7037 of file planner.c.
7040{
7042 PlannerGlobal glob;
7044
7045 /* Make up dummy planner state so we can use setrefs machinery */
7047 glob.type = T_PlannerGlobal;
7050
7053 root.glob = &glob;
7054
7055 /*
7056 * Convert named-argument function calls, insert default arguments and
7057 * simplify constant subexprs. Collect identities of inlined functions
7058 * and elided domains, too.
7059 */
7061
7062 /* Fill in opfuncid values if missing */
7064
7065 /*
7066 * Now walk the finished expression to find anything else we ought to
7067 * record as an expression dependency.
7068 */
7070
7071 *relationOids = glob.relationOids;
7072 *invalItems = glob.invalItems;
7073
7075}
bool extract_query_dependencies_walker(Node *node, PlannerInfo *context)
Definition setrefs.c:3749
Definition pathnodes.h:169
Definition pathnodes.h:303
References eval_const_expressions(), extract_query_dependencies_walker(), fb(), fix_opfuncids(), PlannerGlobal::invalItems, MemSet, NIL, PlannerGlobal::relationOids, result, and root.
Referenced by GetCachedExpression().
◆ extract_rollup_sets()
Definition at line 3194 of file planner.c.
3195{
3201 List **results;
3205 short **adjacency;
3213
3214 /*
3215 * Start by stripping out empty sets. The algorithm doesn't require this,
3216 * but the planner currently needs all empty sets to be returned in the
3217 * first list, so we strip them here and add them back after.
3218 */
3220 {
3221 ++num_empty;
3223 }
3224
3225 /* bail out now if it turns out that all we had were empty sets. */
3228
3229 /*----------
3230 * We don't strictly need to remove duplicate sets here, but if we don't,
3231 * they tend to become scattered through the result, which is a bit
3232 * confusing (and irritating if we ever decide to optimize them out).
3233 * So we remove them here and add them back after.
3234 *
3235 * For each non-duplicate set, we fill in the following:
3236 *
3237 * orig_sets[i] = list of the original set lists
3238 * set_masks[i] = bitmapset for testing inclusion
3239 * adjacency[i] = array [n, v1, v2, ... vn] of adjacency indices
3240 *
3241 * chains[i] will be the result group this set is assigned to.
3242 *
3243 * We index all of these from 1 rather than 0 because it is convenient
3244 * to leave 0 free for the NIL node in the graph algorithm.
3245 *----------
3246 */
3251
3252 j_size = 0;
3253 j = 0;
3254 i = 1;
3255
3257 {
3262
3264 {
3266 }
3267
3268 /* we can only be a dup if we're the same length as a previous set */
3270 {
3271 int k;
3272
3274 {
3276 {
3277 dup_of = k;
3278 break;
3279 }
3280 }
3281 }
3283 {
3286 }
3287
3289 {
3292 }
3293 else
3294 {
3295 int k;
3297
3300
3301 /* fill in adjacency list; no need to compare equal-size sets */
3302
3304 {
3307 }
3308
3310 {
3314 }
3315 else
3317
3318 ++i;
3319 }
3320 }
3321
3323
3324 /*
3325 * Apply the graph matching algorithm to do the work.
3326 */
3328
3329 /*
3330 * Now, the state->pair* fields have the info we need to assign sets to
3331 * chains. Two sets (u,v) belong to the same chain if pair_uv[u] = v or
3332 * pair_vu[v] = u (both will be true, but we check both so that we can do
3333 * it in one pass)
3334 */
3336
3338 {
3341
3346 else
3348 }
3349
3350 /* build result lists. */
3352
3354 {
3356
3358
3360 }
3361
3362 /* push any empty sets back on the first list. */
3365
3366 /* make result list */
3369
3370 /*
3371 * Free all the things.
3372 *
3373 * (This is over-fussy for small sets but for large sets we could have
3374 * tied up a nontrivial amount of memory.)
3375 */
3377 pfree(results);
3382 pfree(adjacency);
3388
3390}
BipartiteMatchState * BipartiteMatch(int u_size, int v_size, short **adjacency)
Definition bipartite_match.c:39
void BipartiteMatchFree(BipartiteMatchState *state)
Definition bipartite_match.c:78
Definition bipartite_match.h:28
Definition regguts.h:331
References Assert, BipartiteMatch(), BipartiteMatchFree(), bms_add_member(), bms_equal(), bms_free(), bms_is_subset(), fb(), for_each_cell, i, j, lappend(), lcons(), lfirst, lfirst_int, list_concat(), list_head(), list_length(), list_make1, lnext(), memcpy(), NIL, palloc(), palloc0(), pfree(), and result.
Referenced by preprocess_grouping_sets().
◆ find_having_conflicts()
Definition at line 1587 of file planner.c.
1588{
1590 having_grouping_ctx ctx;
1592
1595
1597 ctx.group_rtindex = group_rtindex;
1598
1599 idx = 0;
1601 {
1603 &ctx))
1605 idx++;
1606 }
1607
1609}
bool expression_has_grouping_conflict(Node *expr, grouping_eqop_callback get_eqop, void *context)
Definition clauses.c:6318
static Oid having_var_grouping_eqop(Var *var, void *context)
Definition planner.c:1619
Definition planner.c:142
References bms_add_member(), expression_has_grouping_conflict(), fb(), foreach_ptr, having_grouping_ctx::group_rtindex, having_var_grouping_eqop(), idx(), having_grouping_ctx::parse, parse(), and result.
Referenced by subquery_planner().
◆ gather_grouping_paths()
|
static |
Definition at line 8017 of file planner.c.
8018{
8022
8023 /*
8024 * This occurs after any partial aggregation has taken place, so trim off
8025 * any pathkeys added for ORDER BY / DISTINCT aggregates.
8026 */
8029 root->num_groupby_pathkeys);
8030 else
8032
8033 /* Try Gather for unordered paths and Gather Merge for ordered ones. */
8035
8037
8038 /* XXX Shouldn't this also consider the group-key-reordering? */
8040 {
8043 int presorted_keys;
8045
8047 path->pathkeys,
8048 &presorted_keys);
8049
8051 continue;
8052
8053 /*
8054 * Try at least sorting the cheapest path and also try incrementally
8055 * sorting any path which is partially sorted already (no need to deal
8056 * with paths which have presorted keys when incremental sort is
8057 * disabled unless it's the cheapest input path).
8058 */
8060 (presorted_keys == 0 || !enable_incremental_sort))
8061 continue;
8062
8063 /*
8064 * We've no need to consider both a sort and incremental sort. We'll
8065 * just do a sort if there are no presorted keys and an incremental
8066 * sort when there are presorted keys.
8067 */
8070 groupby_pathkeys,
8071 -1.0);
8072 else
8074 rel,
8075 path,
8076 groupby_pathkeys,
8077 presorted_keys,
8078 -1.0);
8080 path = (Path *)
8082 rel,
8083 path,
8084 rel->reltarget,
8085 groupby_pathkeys,
8086 NULL,
8087 &total_groups);
8088
8089 add_path(rel, path);
8090 }
8091}
References add_path(), compute_gather_rows(), create_gather_merge_path(), create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, fb(), generate_useful_gather_paths(), lfirst, linitial, list_copy_head(), list_length(), RelOptInfo::partial_pathlist, Path::pathkeys, pathkeys_count_contained_in(), RelOptInfo::reltarget, and root.
Referenced by add_paths_to_grouping_rel(), and create_ordinary_grouping_paths().
◆ generate_setop_child_grouplist()
|
static |
Definition at line 8607 of file planner.c.
8608{
8611 ListCell *lt;
8613
8616 foreach(lt, targetlist)
8617 {
8620 Oid coltype;
8621
8622 /* resjunk columns could have sortgrouprefs. Leave these alone */
8624 continue;
8625
8626 /*
8627 * We expect every non-resjunk target to have a SortGroupClause and
8628 * colTypes.
8629 */
8634
8635 /* reject if target type isn't the same as the setop target type */
8638
8641
8642 /* assign a tleSortGroupRef, or reuse the existing one */
8644 }
8645
8648
8650}
References Assert, assignSortGroupRef(), copyObject, exprType(), fb(), lfirst, lfirst_oid, list_head(), lnext(), and NIL.
Referenced by standard_qp_callback().
◆ get_cheapest_fractional_path()
| Path * get_cheapest_fractional_path | ( | RelOptInfo * | rel, |
| double | tuple_fraction | ||
| ) |
Definition at line 6848 of file planner.c.
6849{
6851 ListCell *l;
6852
6853 /* If all tuples will be retrieved, just return the cheapest-total path */
6854 if (tuple_fraction <= 0.0)
6856
6857 /* Convert absolute # of tuples to a fraction; no need to clamp to 0..1 */
6859 tuple_fraction /= best_path->rows;
6860
6862 {
6864
6865 if (path->param_info)
6866 continue;
6867
6870 continue;
6871
6872 best_path = path;
6873 }
6874
6876}
int compare_fractional_path_costs(Path *path1, Path *path2, double fraction)
Definition pathnode.c:123
References RelOptInfo::cheapest_total_path, compare_fractional_path_costs(), fb(), lfirst, and RelOptInfo::pathlist.
Referenced by add_paths_to_append_rel(), make_subplan(), and standard_planner().
◆ get_number_of_groups()
|
static |
Definition at line 3928 of file planner.c.
3932{
3935
3937 {
3939
3941 {
3942 /* Add up the estimates for each grouping set */
3944
3946
3947 dNumGroups = 0;
3948
3950 {
3954
3956 target_list);
3957
3958 rollup->numGroups = 0.0;
3959
3961 {
3965 groupExprs,
3966 path_rows,
3967 &gset,
3968 NULL);
3969
3970 gs->numGroups = numGroups;
3971 rollup->numGroups += numGroups;
3972 }
3973
3975 }
3976
3978 {
3980
3981 gd->dNumHashGroups = 0;
3982
3984 target_list);
3985
3987 {
3991 groupExprs,
3992 path_rows,
3993 &gset,
3994 NULL);
3995
3996 gs->numGroups = numGroups;
3997 gd->dNumHashGroups += numGroups;
3998 }
3999
4001 }
4002 }
4003 else
4004 {
4005 /* Plain GROUP BY -- estimate based on optimized groupClause */
4007 target_list);
4008
4011 }
4012 }
4014 {
4015 /* Empty grouping sets ... one result row for each one */
4017 }
4019 {
4020 /* Plain aggregation, one result row */
4021 dNumGroups = 1;
4022 }
4023 else
4024 {
4025 /* Not grouping */
4026 dNumGroups = 1;
4027 }
4028
4030}
References Assert, estimate_num_groups(), fb(), forboth, get_sortgrouplist_exprs(), lfirst, lfirst_node, list_length(), parse(), and root.
Referenced by add_paths_to_grouping_rel(), and create_partial_grouping_paths().
◆ get_useful_pathkeys_for_distinct()
|
static |
Definition at line 5486 of file planner.c.
5488{
5491
5492 /* always include the given 'needed_pathkeys' */
5494 needed_pathkeys);
5495
5498
5499 /*
5500 * Scan the given 'path_pathkeys' and construct a list of PathKey nodes
5501 * that match 'needed_pathkeys', but only up to the longest matching
5502 * prefix.
5503 *
5504 * When we have DISTINCT ON, we must ensure that the resulting pathkey
5505 * list matches initial distinctClause pathkeys; otherwise, it won't have
5506 * the desired behavior.
5507 */
5509 {
5510 /*
5511 * The PathKey nodes are canonical, so they can be checked for
5512 * equality by simple pointer comparison.
5513 */
5515 break;
5518 break;
5519
5521 }
5522
5523 /* If no match at all, no point in reordering needed_pathkeys */
5526
5527 /*
5528 * If not full match, the resulting pathkey list is not useful without
5529 * incremental sort.
5530 */
5532 !enable_incremental_sort)
5534
5535 /* Append the remaining PathKey nodes in needed_pathkeys */
5537 needed_pathkeys);
5538
5539 /*
5540 * If the resulting pathkey list is the same as the 'needed_pathkeys',
5541 * just drop it.
5542 */
5546
5548 useful_pathkeys);
5549
5551}
List * list_concat_unique_ptr(List *list1, const List *list2)
Definition list.c:1427
Definition pathnodes.h:1807
References compare_pathkeys(), enable_distinct_reordering, enable_incremental_sort, fb(), foreach_node, lappend(), list_concat_unique_ptr(), list_length(), list_member_ptr(), NIL, PATHKEYS_EQUAL, and root.
Referenced by create_final_distinct_paths(), and create_partial_distinct_paths().
◆ group_by_has_partkey()
|
static |
Definition at line 8520 of file planner.c.
8523{
8525 int cnt = 0;
8526 int partnatts;
8527
8528 /* Input relation should be partitioned. */
8530
8531 /* Rule out early, if there are no partition keys present. */
8533 return false;
8534
8535 partnatts = input_rel->part_scheme->partnatts;
8536
8537 for (cnt = 0; cnt < partnatts; cnt++)
8538 {
8541 bool found = false;
8542
8544 {
8548
8550 {
8553
8554 /*
8555 * Note: we can assume there is at most one RelabelType node;
8556 * eval_const_expressions() will have simplified if more than
8557 * one.
8558 */
8561
8563 {
8564 /*
8565 * Reject a match if the grouping collation does not match
8566 * the partitioning collation.
8567 */
8570 return false;
8571
8572 found = true;
8573 break;
8574 }
8575 }
8576
8577 if (found)
8578 break;
8579 }
8580
8581 /*
8582 * If none of the partition key expressions match with any of the
8583 * GROUP BY expression, return false.
8584 */
8585 if (!found)
8586 return false;
8587 }
8588
8589 return true;
8590}
References Assert, equal(), exprCollation(), fb(), get_sortgrouplist_exprs(), IsA, lfirst, and OidIsValid.
Referenced by create_ordinary_grouping_paths().
◆ group_var_eqop()
Definition at line 1640 of file planner.c.
1641{
1642 int counter = 0;
1643
1645
1647 {
1649 continue;
1652 }
1653
1655 var->varattno);
1657}
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition tlist.c:376
References Assert, elog, ERROR, fb(), foreach_node, get_sortgroupclause_tle(), InvalidOid, parse(), Var::varattno, and Var::varlevelsup.
Referenced by having_var_grouping_eqop().
◆ grouping_planner()
|
static |
Definition at line 1704 of file planner.c.
1706{
1708 int64 offset_est = 0;
1709 int64 count_est = 0;
1710 double limit_tuples = -1.0;
1718 FinalPathExtraData extra;
1720
1721 /* Tweak caller-supplied tuple_fraction if have LIMIT/OFFSET */
1723 {
1725 &offset_est, &count_est);
1726
1727 /*
1728 * If we have a known LIMIT, and don't have an unknown OFFSET, we can
1729 * estimate the effects of using a bounded sort.
1730 */
1731 if (count_est > 0 && offset_est >= 0)
1733 }
1734
1735 /* Make tuple_fraction accessible to lower-level routines */
1736 root->tuple_fraction = tuple_fraction;
1737
1739 {
1740 /*
1741 * Construct Paths for set operations. The results will not need any
1742 * work except perhaps a top-level sort and/or LIMIT. Note that any
1743 * special work for recursive unions is the responsibility of
1744 * plan_set_operations.
1745 */
1747
1748 /*
1749 * We should not need to call preprocess_targetlist, since we must be
1750 * in a SELECT query node. Instead, use the processed_tlist returned
1751 * by plan_set_operations (since this tells whether it returned any
1752 * resjunk columns!), and transfer any sort key information from the
1753 * original tlist.
1754 */
1756
1757 /* for safety, copy processed_tlist instead of modifying in-place */
1758 root->processed_tlist =
1760 parse->targetList);
1761
1762 /* Also extract the PathTarget form of the setop result tlist */
1764
1765 /* And check whether it's parallel safe */
1766 final_target_parallel_safe =
1768
1769 /* The setop result tlist couldn't contain any SRFs */
1772
1773 /*
1774 * Can't handle FOR [KEY] UPDATE/SHARE here (parser should have
1775 * checked already, but let's make sure).
1776 */
1780 /*------
1781 translator: %s is a SQL row locking clause such as FOR UPDATE */
1784 parse->rowMarks)->strength))));
1785
1786 /*
1787 * Calculate pathkeys that represent result ordering requirements
1788 */
1791 parse->sortClause,
1792 root->processed_tlist);
1793 }
1794 else
1795 {
1796 /* No set operations, do regular planning */
1815
1816 /* A recursive query should always have setOperations */
1818
1819 /* Preprocess grouping sets and GROUP BY clause, if any */
1821 {
1823 }
1825 {
1826 /* Preprocess regular GROUP BY clause, if any */
1828 }
1829
1830 /*
1831 * Preprocess targetlist. Note that much of the remaining planning
1832 * work will be done with the PathTarget representation of tlists, but
1833 * we must also maintain the full representation of the final tlist so
1834 * that we can transfer its decoration (resnames etc) to the topmost
1835 * tlist of the finished Plan. This is kept in processed_tlist.
1836 */
1838
1839 /*
1840 * Mark all the aggregates with resolved aggtranstypes, and detect
1841 * aggregates that are duplicates or can share transition state. We
1842 * must do this before slicing and dicing the tlist into various
1843 * pathtargets, else some copies of the Aggref nodes might escape
1844 * being marked.
1845 */
1847 {
1850 }
1851
1852 /*
1853 * Locate any window functions in the tlist. (We don't need to look
1854 * anywhere else, since expressions used in ORDER BY will be in there
1855 * too.) Note that they could all have been eliminated by constant
1856 * folding, in which case we don't need to do any more work.
1857 */
1859 {
1863 {
1864 /*
1865 * See if any modifications can be made to each WindowClause
1866 * to allow the executor to execute the WindowFuncs more
1867 * quickly.
1868 */
1870
1871 /* Extract the list of windows actually in use. */
1873
1874 /* Make sure they all have names, for EXPLAIN's use. */
1875 name_active_windows(activeWindows);
1876 }
1877 else
1879 }
1880
1881 /*
1882 * Preprocess MIN/MAX aggregates, if any. Note: be careful about
1883 * adding logic between here and the query_planner() call. Anything
1884 * that is needed in MIN/MAX-optimizable cases will have to be
1885 * duplicated in planagg.c.
1886 */
1889
1890 /*
1891 * Figure out whether there's a hard limit on the number of rows that
1892 * query_planner's result subplan needs to return. Even if we know a
1893 * hard limit overall, it doesn't apply if the query has any
1894 * grouping/aggregation operations, or SRFs in the tlist.
1895 */
1897 parse->groupingSets ||
1898 parse->distinctClause ||
1899 parse->hasAggs ||
1900 parse->hasWindowFuncs ||
1901 parse->hasTargetSRFs ||
1902 root->hasHavingQual)
1903 root->limit_tuples = -1.0;
1904 else
1905 root->limit_tuples = limit_tuples;
1906
1907 /* Set up data needed by standard_qp_callback */
1908 qp_extra.activeWindows = activeWindows;
1909 qp_extra.gset_data = gset_data;
1910
1911 /*
1912 * If we're a subquery for a set operation, store the SetOperationStmt
1913 * in qp_extra.
1914 */
1916
1917 /*
1918 * Generate the best unsorted and presorted paths for the scan/join
1919 * portion of this Query, ie the processing represented by the
1920 * FROM/WHERE clauses. (Note there may not be any presorted paths.)
1921 * We also generate (in standard_qp_callback) pathkey representations
1922 * of the query's sort clause, distinct clause, etc.
1923 */
1925
1926 /*
1927 * Convert the query's result tlist into PathTarget format.
1928 *
1929 * Note: this cannot be done before query_planner() has performed
1930 * appendrel expansion, because that might add resjunk entries to
1931 * root->processed_tlist. Waiting till afterwards is also helpful
1932 * because the target width estimates can use per-Var width numbers
1933 * that were obtained within query_planner().
1934 */
1936 final_target_parallel_safe =
1938
1939 /*
1940 * If ORDER BY was given, consider whether we should use a post-sort
1941 * projection, and compute the adjusted target for preceding steps if
1942 * so.
1943 */
1945 {
1947 final_target,
1948 &have_postponed_srfs);
1951 }
1952 else
1953 {
1956 }
1957
1958 /*
1959 * If we have window functions to deal with, the output from any
1960 * grouping step needs to be what the window functions want;
1961 * otherwise, it should be sort_input_target.
1962 */
1963 if (activeWindows)
1964 {
1966 final_target,
1967 activeWindows);
1970 }
1971 else
1972 {
1975 }
1976
1977 /*
1978 * If we have grouping or aggregation to do, the topmost scan/join
1979 * plan node must emit what the grouping step wants; otherwise, it
1980 * should emit grouping_target.
1981 */
1985 {
1989 }
1990 else
1991 {
1994 }
1995
1996 /*
1997 * If there are any SRFs in the targetlist, we must separate each of
1998 * these PathTargets into SRF-computing and SRF-free targets. Replace
1999 * each of the named targets with a SRF-free version, and remember the
2000 * list of additional projection steps we need to add afterwards.
2001 */
2003 {
2004 /* final_target doesn't recompute any SRFs in sort_input_target */
2006 &final_targets,
2007 &final_targets_contain_srfs);
2010 /* likewise for sort_input_target vs. grouping_target */
2012 &sort_input_targets,
2013 &sort_input_targets_contain_srfs);
2016 /* likewise for grouping_target vs. scanjoin_target */
2019 &grouping_targets,
2020 &grouping_targets_contain_srfs);
2023 /* scanjoin_target will not have any SRFs precomputed for it */
2025 &scanjoin_targets,
2026 &scanjoin_targets_contain_srfs);
2029 }
2030 else
2031 {
2032 /* initialize lists; for most of these, dummy values are OK */
2038 }
2039
2040 /* Apply scan/join target. */
2046 scanjoin_target_same_exprs);
2047
2048 /*
2049 * Save the various upper-rel PathTargets we just computed into
2050 * root->upper_targets[]. The core code doesn't use this, but it
2051 * provides a convenient place for extensions to get at the info. For
2052 * consistency, we save all the intermediate targets, even though some
2053 * of the corresponding upperrels might not be needed for this query.
2054 */
2061
2062 /*
2063 * If we have grouping and/or aggregation, consider ways to implement
2064 * that. We build a new upperrel representing the output of this
2065 * phase.
2066 */
2068 {
2070 current_rel,
2071 grouping_target,
2073 gset_data);
2074 /* Fix things up if grouping_target contains SRFs */
2077 grouping_targets,
2079 }
2080
2081 /*
2082 * If we have window functions, consider ways to implement those. We
2083 * build a new upperrel representing the output of this phase.
2084 */
2085 if (activeWindows)
2086 {
2088 current_rel,
2089 grouping_target,
2090 sort_input_target,
2092 wflists,
2093 activeWindows);
2094 /* Fix things up if sort_input_target contains SRFs */
2097 sort_input_targets,
2099 }
2100
2101 /*
2102 * If there is a DISTINCT clause, consider ways to implement that. We
2103 * build a new upperrel representing the output of this phase.
2104 */
2106 {
2108 current_rel,
2109 sort_input_target);
2110 }
2111 } /* end of if (setOperations) */
2112
2113 /*
2114 * If ORDER BY was given, consider ways to implement that, and generate a
2115 * new upperrel containing only paths that emit the correct ordering and
2116 * project the correct final_target. We can apply the original
2117 * limit_tuples limit in sort costing here, but only if there are no
2118 * postponed SRFs.
2119 */
2121 {
2123 current_rel,
2124 final_target,
2126 have_postponed_srfs ? -1.0 :
2127 limit_tuples);
2128 /* Fix things up if final_target contains SRFs */
2131 final_targets,
2132 final_targets_contain_srfs);
2133 }
2134
2135 /*
2136 * Now we are prepared to build the final-output upperrel.
2137 */
2139
2140 /*
2141 * If the input rel is marked consider_parallel and there's nothing that's
2142 * not parallel-safe in the LIMIT clause, then the final_rel can be marked
2143 * consider_parallel as well. Note that if the query has rowMarks or is
2144 * not a SELECT, consider_parallel will be false for every relation in the
2145 * query.
2146 */
2151
2152 /*
2153 * If the current_rel belongs to a single FDW, so does the final_rel.
2154 */
2159
2160 /*
2161 * Generate paths for the final_rel. Insert all surviving paths, with
2162 * LockRows, Limit, and/or ModifyTable steps added if needed.
2163 */
2165 {
2167
2168 /*
2169 * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows node.
2170 * (Note: we intentionally test parse->rowMarks not root->rowMarks
2171 * here. If there are only non-locking rowmarks, they should be
2172 * handled by the ModifyTable node instead. However, root->rowMarks
2173 * is what goes into the LockRows node.)
2174 */
2176 {
2178 root->rowMarks,
2180 }
2181
2182 /*
2183 * If there is a LIMIT/OFFSET clause, add the LIMIT node.
2184 */
2186 {
2188 parse->limitOffset,
2189 parse->limitCount,
2190 parse->limitOption,
2191 offset_est, count_est);
2192 }
2193
2194 /*
2195 * If this is an INSERT/UPDATE/DELETE/MERGE, add the ModifyTable node.
2196 */
2198 {
2199 Index rootRelation;
2206 List *rowMarks;
2207
2209 {
2210 /* Inherited UPDATE/DELETE/MERGE */
2212 parse->resultRelation);
2213 int resultRelation = -1;
2214
2215 /* Pass the root result rel forward to the executor. */
2216 rootRelation = parse->resultRelation;
2217
2218 /* Add only leaf children to ModifyTable. */
2220 resultRelation)) >= 0)
2221 {
2223 resultRelation);
2224
2225 /*
2226 * Also exclude any leaf rels that have turned dummy since
2227 * being added to the list, for example, by being excluded
2228 * by constraint exclusion.
2229 */
2231 continue;
2232
2233 /* Build per-target-rel lists needed by ModifyTable */
2234 resultRelations = lappend_int(resultRelations,
2235 resultRelation);
2237 {
2239
2241 update_colnos =
2243 update_colnos,
2244 this_result_rel->relid,
2245 top_result_rel->relid);
2246 updateColnosLists = lappend(updateColnosLists,
2247 update_colnos);
2248 }
2250 {
2252
2257 this_result_rel,
2258 top_result_rel);
2259 withCheckOptionLists = lappend(withCheckOptionLists,
2260 withCheckOptions);
2261 }
2263 {
2265
2267 returningList = (List *)
2269 (Node *) returningList,
2270 this_result_rel,
2271 top_result_rel);
2272 returningLists = lappend(returningLists,
2273 returningList);
2274 }
2276 {
2277 ListCell *l;
2279
2280 /*
2281 * Copy MergeActions and translate stuff that
2282 * references attribute numbers.
2283 */
2285 {
2288
2289 leaf_action->qual =
2292 this_result_rel,
2293 top_result_rel);
2297 this_result_rel,
2298 top_result_rel);
2300 leaf_action->updateColnos =
2302 action->updateColnos,
2303 this_result_rel->relid,
2304 top_result_rel->relid);
2305 mergeActionList = lappend(mergeActionList,
2306 leaf_action);
2307 }
2308
2309 mergeActionLists = lappend(mergeActionLists,
2310 mergeActionList);
2311 }
2313 {
2315
2317 mergeJoinCondition =
2319 mergeJoinCondition,
2320 this_result_rel,
2321 top_result_rel);
2322 mergeJoinConditions = lappend(mergeJoinConditions,
2323 mergeJoinCondition);
2324 }
2325 }
2326
2328 {
2329 /*
2330 * We managed to exclude every child rel, so generate a
2331 * dummy one-relation plan using info for the top target
2332 * rel (even though that may not be a leaf target).
2333 * Although it's clear that no data will be updated or
2334 * deleted, we still need to have a ModifyTable node so
2335 * that any statement triggers will be executed. (This
2336 * could be cleaner if we fixed nodeModifyTable.c to allow
2337 * zero target relations, but that probably wouldn't be a
2338 * net win.)
2339 */
2351 }
2352 }
2353 else
2354 {
2355 /* Single-relation INSERT/UPDATE/DELETE/MERGE. */
2356 rootRelation = 0; /* there's no separate root rel */
2368 }
2369
2370 /*
2371 * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node
2372 * will have dealt with fetching non-locked marked rows, else we
2373 * need to have ModifyTable do that.
2374 */
2376 rowMarks = NIL;
2377 else
2378 rowMarks = root->rowMarks;
2379
2380 path = (Path *)
2382 path,
2383 parse->commandType,
2384 parse->canSetTag,
2385 parse->resultRelation,
2386 rootRelation,
2387 resultRelations,
2388 updateColnosLists,
2389 withCheckOptionLists,
2390 returningLists,
2391 rowMarks,
2392 parse->onConflict,
2393 mergeActionLists,
2394 mergeJoinConditions,
2395 parse->forPortionOf,
2397 }
2398
2399 /* And shove it into final_rel */
2401 }
2402
2403 /*
2404 * Generate partial paths for final_rel, too, if outer query levels might
2405 * be able to make use of them.
2406 */
2408 !limit_needed(parse))
2409 {
2412 {
2414
2416 }
2417 }
2418
2420 extra.limit_tuples = limit_tuples;
2421 extra.count_est = count_est;
2422 extra.offset_est = offset_est;
2423
2424 /*
2425 * If there is an FDW that's responsible for all baserels of the query,
2426 * let it consider adding ForeignPaths.
2427 */
2429 final_rel->fdwroutine->GetForeignUpperPaths)
2432 &extra);
2433
2434 /* Let extensions possibly add some more paths */
2438
2439 /* Note: currently, we leave it to callers to do set_cheapest() */
2440}
List * adjust_inherited_attnums_multilevel(PlannerInfo *root, List *attnums, Index child_relid, Index top_parent_relid)
Definition appendinfo.c:738
WindowFuncLists * find_window_functions(Node *clause, Index maxWinRef)
Definition clauses.c:260
int assign_special_exec_param(PlannerInfo *root)
Definition paramassign.c:754
LockRowsPath * create_lockrows_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *rowMarks, int epqParam)
Definition pathnode.c:3630
ModifyTablePath * create_modifytable_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, CmdType operation, bool canSetTag, Index nominalRelation, Index rootRelation, List *resultRelations, List *updateColnosLists, List *withCheckOptionLists, List *returningLists, List *rowMarks, OnConflictExpr *onconflict, List *mergeActionLists, List *mergeJoinConditions, ForPortionOfExpr *forPortionOf, int epqParam)
Definition pathnode.c:3692
void preprocess_minmax_aggregates(PlannerInfo *root)
Definition planagg.c:74
RelOptInfo * query_planner(PlannerInfo *root, query_pathkeys_callback qp_callback, void *qp_extra)
Definition planmain.c:54
static List * postprocess_setop_tlist(List *new_tlist, List *orig_tlist)
Definition planner.c:6044
static double preprocess_limit(PlannerInfo *root, double tuple_fraction, int64 *offset_est, int64 *count_est)
Definition planner.c:2847
static PathTarget * make_window_input_target(PlannerInfo *root, PathTarget *final_target, List *activeWindows)
Definition planner.c:6424
static RelOptInfo * create_distinct_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target)
Definition planner.c:5053
static void optimize_window_clauses(PlannerInfo *root, WindowFuncLists *wflists)
Definition planner.c:6081
static PathTarget * make_sort_input_target(PlannerInfo *root, PathTarget *final_target, bool *have_postponed_srfs)
Definition planner.c:6672
static grouping_sets_data * preprocess_grouping_sets(PlannerInfo *root)
Definition planner.c:2452
static PathTarget * make_group_input_target(PlannerInfo *root, PathTarget *final_target)
Definition planner.c:5794
static List * select_active_windows(PlannerInfo *root, WindowFuncLists *wflists)
Definition planner.c:6221
static RelOptInfo * create_ordered_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, double limit_tuples)
Definition planner.c:5571
static RelOptInfo * create_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *target, bool target_parallel_safe, grouping_sets_data *gd)
Definition planner.c:4050
static void standard_qp_callback(PlannerInfo *root, void *extra)
Definition planner.c:3723
static RelOptInfo * create_window_paths(PlannerInfo *root, RelOptInfo *input_rel, PathTarget *input_target, PathTarget *output_target, bool output_target_parallel_safe, WindowFuncLists *wflists, List *activeWindows)
Definition planner.c:4796
Definition pathnodes.h:3705
Definition primnodes.h:2025
Definition parsenodes.h:1693
Definition clauses.h:20
Definition planner.c:106
Definition planner.c:130
void split_pathtarget_at_srfs_grouping(PlannerInfo *root, PathTarget *target, PathTarget *input_target, List **targets, List **targets_contain_srfs)
Definition tlist.c:868
void split_pathtarget_at_srfs(PlannerInfo *root, PathTarget *target, PathTarget *input_target, List **targets, List **targets_contain_srfs)
Definition tlist.c:845
References add_partial_path(), add_path(), adjust_appendrel_attrs_multilevel(), adjust_inherited_attnums_multilevel(), adjust_paths_for_srfs(), apply_scanjoin_target_to_paths(), Assert, assign_special_exec_param(), bms_membership(), BMS_MULTIPLE, bms_next_member(), CMD_MERGE, CMD_SELECT, CMD_UPDATE, copyObject, FinalPathExtraData::count_est, create_distinct_paths(), create_grouping_paths(), create_limit_path(), create_lockrows_path(), create_modifytable_path(), create_ordered_paths(), create_pathtarget, create_upper_paths_hook, create_window_paths(), equal(), ereport, errcode(), errmsg, ERROR, fb(), fetch_upper_rel(), find_base_rel(), find_window_functions(), IS_DUMMY_REL, is_parallel_safe(), lappend(), lappend_int(), LCS_asString(), lfirst, limit_needed(), FinalPathExtraData::limit_needed, FinalPathExtraData::limit_tuples, linitial_int, linitial_node, list_length(), list_make1, list_make1_int, make_group_input_target(), make_pathkeys_for_sortclauses(), make_sort_input_target(), make_window_input_target(), name_active_windows(), NIL, FinalPathExtraData::offset_est, optimize_window_clauses(), parse(), plan_set_operations(), postprocess_setop_tlist(), preprocess_aggrefs(), preprocess_groupclause(), preprocess_grouping_sets(), preprocess_limit(), preprocess_minmax_aggregates(), preprocess_targetlist(), query_planner(), root, select_active_windows(), split_pathtarget_at_srfs(), split_pathtarget_at_srfs_grouping(), standard_qp_callback(), UPPERREL_DISTINCT, UPPERREL_FINAL, UPPERREL_GROUP_AGG, UPPERREL_ORDERED, UPPERREL_PARTIAL_DISTINCT, and UPPERREL_WINDOW.
Referenced by subquery_planner().
◆ has_volatile_pathkey()
Definition at line 3454 of file planner.c.
3455{
3457
3459 {
3461
3463 return true;
3464 }
3465
3466 return false;
3467}
References fb(), and lfirst_node.
Referenced by adjust_group_pathkeys_for_groupagg().
◆ having_var_grouping_eqop()
Definition at line 1619 of file planner.c.
1620{
1622
1625
1627}
References having_grouping_ctx::group_rtindex, group_var_eqop(), InvalidOid, having_grouping_ctx::parse, Var::varlevelsup, and Var::varno.
Referenced by find_having_conflicts().
◆ is_degenerate_grouping()
|
static |
◆ limit_needed()
Definition at line 3032 of file planner.c.
3033{
3034 Node *node;
3035
3036 node = parse->limitCount;
3037 if (node)
3038 {
3040 {
3041 /* NULL indicates LIMIT ALL, ie, no limit */
3043 return true; /* LIMIT with a constant value */
3044 }
3045 else
3046 return true; /* non-constant LIMIT */
3047 }
3048
3049 node = parse->limitOffset;
3050 if (node)
3051 {
3053 {
3054 /* Treat NULL as no offset; the executor would too */
3056 {
3058
3059 if (offset != 0)
3060 return true; /* OFFSET with a nonzero value */
3061 }
3062 }
3063 else
3064 return true; /* non-constant OFFSET */
3065 }
3066
3067 return false; /* don't need a Limit plan node */
3068}
References DatumGetInt64(), fb(), IsA, and parse().
Referenced by grouping_planner(), and set_rel_consider_parallel().
◆ make_group_input_target()
|
static |
Definition at line 5794 of file planner.c.
5795{
5802
5803 /*
5804 * We must build a target containing all grouping columns, plus any other
5805 * Vars mentioned in the query's targetlist and HAVING qual.
5806 */
5809
5810 i = 0;
5812 {
5815
5819 {
5820 /*
5821 * It's a grouping column, so add it to the input target as-is.
5822 *
5823 * Note that the target is logically below the grouping step. So
5824 * with grouping sets we need to remove the RT index of the
5825 * grouping step if there is any from the target expression.
5826 */
5828 {
5830 expr = (Expr *)
5833 NULL);
5834 }
5836 }
5837 else
5838 {
5839 /*
5840 * Non-grouping column, so just remember the expression for later
5841 * call to pull_var_clause.
5842 */
5844 }
5845
5846 i++;
5847 }
5848
5849 /*
5850 * If there's a HAVING clause, we'll need the Vars it uses, too.
5851 */
5854
5855 /*
5856 * Pull out all the Vars mentioned in non-group cols (plus HAVING), and
5857 * add them to the input target if not already present. (A Var used
5858 * directly as a GROUP BY item will be present already.) Note this
5859 * includes Vars used in resjunk items, so we are covering the needs of
5860 * ORDER BY and window specifications. Vars used within Aggrefs and
5861 * WindowFuncs will be pulled out here, too.
5862 *
5863 * Note that the target is logically below the grouping step. So with
5864 * grouping sets we need to remove the RT index of the grouping step if
5865 * there is any from the non-group Vars.
5866 */
5868 PVC_RECURSE_AGGREGATES |
5869 PVC_RECURSE_WINDOWFUNCS |
5870 PVC_INCLUDE_PLACEHOLDERS);
5872 {
5877 NULL);
5878 }
5880
5881 /* clean up cruft */
5884
5885 /* XXX this causes some redundant cost calculation ... */
5887}
PathTarget * set_pathtarget_cost_width(PlannerInfo *root, PathTarget *target)
Definition costsize.c:6511
#define get_pathtarget_sortgroupref(target, colno)
Definition pathnodes.h:1894
Node * remove_nulling_relids(Node *node, const Bitmapset *removable_relids, const Bitmapset *except_relids)
Definition rewriteManip.c:1340
SortGroupClause * get_sortgroupref_clause_noerr(Index sortref, List *clauses)
Definition tlist.c:452
void add_new_columns_to_pathtarget(PathTarget *target, List *exprs)
Definition tlist.c:761
References add_column_to_pathtarget(), add_new_columns_to_pathtarget(), Assert, bms_make_singleton(), create_empty_pathtarget(), fb(), get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), i, lappend(), lfirst, list_free(), NIL, parse(), pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_AGGREGATES, PVC_RECURSE_WINDOWFUNCS, remove_nulling_relids(), root, and set_pathtarget_cost_width().
Referenced by grouping_planner().
◆ make_grouping_rel()
|
static |
Definition at line 4163 of file planner.c.
4166{
4167 RelOptInfo *grouped_rel;
4168
4170 {
4172 input_rel->relids);
4174 }
4175 else
4176 {
4177 /*
4178 * By tradition, the relids set for the main grouping relation is
4179 * NULL. (This could be changed, but might require adjustments
4180 * elsewhere.)
4181 */
4183 }
4184
4185 /* Set target. */
4186 grouped_rel->reltarget = target;
4187
4188 /*
4189 * If the input relation is not parallel-safe, then the grouped relation
4190 * can't be parallel-safe, either. Otherwise, it's parallel-safe if the
4191 * target list and HAVING quals are parallel-safe.
4192 */
4196
4197 /* Assume that the same path generation strategies are allowed */
4199
4200 /*
4201 * If the input rel belongs to a single FDW, so does the grouped rel.
4202 */
4206 grouped_rel->fdwroutine = input_rel->fdwroutine;
4207
4208 return grouped_rel;
4209}
References RelOptInfo::consider_parallel, fb(), fetch_upper_rel(), IS_OTHER_REL, is_parallel_safe(), RelOptInfo::pgs_mask, RELOPT_OTHER_UPPER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, RelOptInfo::serverid, UPPERREL_GROUP_AGG, RelOptInfo::userid, and RelOptInfo::useridiscurrent.
Referenced by create_grouping_paths(), and create_partitionwise_grouping_paths().
◆ make_ordered_path()
|
static |
Definition at line 7958 of file planner.c.
7960{
7962 int presorted_keys;
7963
7965 path->pathkeys,
7966 &presorted_keys);
7967
7969 {
7970 /*
7971 * Try at least sorting the cheapest path and also try incrementally
7972 * sorting any path which is partially sorted already (no need to deal
7973 * with paths which have presorted keys when incremental sort is
7974 * disabled unless it's the cheapest input path).
7975 */
7977 (presorted_keys == 0 || !enable_incremental_sort))
7979
7980 /*
7981 * We've no need to consider both a sort and incremental sort. We'll
7982 * just do a sort if there are no presorted keys and an incremental
7983 * sort when there are presorted keys.
7984 */
7987 rel,
7988 path,
7989 pathkeys,
7990 limit_tuples);
7991 else
7993 rel,
7994 path,
7995 pathkeys,
7996 presorted_keys,
7997 limit_tuples);
7998 }
7999
8000 return path;
8001}
References create_incremental_sort_path(), create_sort_path(), enable_incremental_sort, fb(), Path::pathkeys, pathkeys_count_contained_in(), and root.
Referenced by add_paths_to_grouping_rel(), create_final_distinct_paths(), create_partial_distinct_paths(), and create_partial_grouping_paths().
◆ make_partial_grouping_target()
|
static |
Definition at line 5906 of file planner.c.
5909{
5915
5918
5919 i = 0;
5921 {
5924
5928 {
5929 /*
5930 * It's a grouping column, so add it to the partial_target as-is.
5931 * (This allows the upper agg step to repeat the grouping calcs.)
5932 */
5934 }
5935 else
5936 {
5937 /*
5938 * Non-grouping column, so just remember the expression for later
5939 * call to pull_var_clause.
5940 */
5942 }
5943
5944 i++;
5945 }
5946
5947 /*
5948 * If there's a HAVING clause, we'll need the Vars/Aggrefs it uses, too.
5949 */
5950 if (havingQual)
5952
5953 /*
5954 * Pull out all the Vars, PlaceHolderVars, and Aggrefs mentioned in
5955 * non-group cols (plus HAVING), and add them to the partial_target if not
5956 * already present. (An expression used directly as a GROUP BY item will
5957 * be present already.) Note this includes Vars used in resjunk items, so
5958 * we are covering the needs of ORDER BY and window specifications.
5959 */
5961 PVC_INCLUDE_AGGREGATES |
5962 PVC_RECURSE_WINDOWFUNCS |
5963 PVC_INCLUDE_PLACEHOLDERS);
5964
5966
5967 /*
5968 * Adjust Aggrefs to put them in partial mode. At this point all Aggrefs
5969 * are at the top level of the target list, so we can just scan the list
5970 * rather than recursing through the expression trees.
5971 */
5973 {
5975
5977 {
5979
5980 /*
5981 * We shouldn't need to copy the substructure of the Aggref node,
5982 * but flat-copy the node itself to avoid damaging other trees.
5983 */
5986
5987 /* For now, assume serialization is required */
5989
5991 }
5992 }
5993
5994 /* clean up cruft */
5997
5998 /* XXX this causes some redundant cost calculation ... */
6000}
void mark_partial_aggref(Aggref *agg, AggSplit aggsplit)
Definition planner.c:6009
References add_column_to_pathtarget(), add_new_columns_to_pathtarget(), AGGSPLIT_INITIAL_SERIAL, create_empty_pathtarget(), fb(), get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), i, IsA, lappend(), lfirst, list_free(), makeNode, mark_partial_aggref(), memcpy(), NIL, pull_var_clause(), PVC_INCLUDE_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_WINDOWFUNCS, root, and set_pathtarget_cost_width().
Referenced by create_partial_grouping_paths().
◆ make_pathkeys_for_window()
|
static |
Definition at line 6544 of file planner.c.
6546{
6548
6549 /* Throw error if can't sort */
6560
6561 /*
6562 * First fetch the pathkeys for the PARTITION BY clause. We can safely
6563 * remove any clauses from the wc->partitionClause for redundant pathkeys.
6564 */
6566 {
6568
6570 &wc->partitionClause,
6571 tlist,
6572 true,
6573 false,
6574 &sortable,
6575 false);
6576
6578 }
6579
6580 /*
6581 * In principle, we could also consider removing redundant ORDER BY items
6582 * too as doing so does not alter the result of peer row checks done by
6583 * the executor. However, we must *not* remove the ordering column for
6584 * RANGE OFFSET cases, as the executor needs that for in_range tests even
6585 * if it's known to be equal to some partitioning column.
6586 */
6588 {
6590
6592 wc->orderClause,
6593 tlist);
6594
6595 /* Okay, make the combined pathkeys */
6598 else
6599 window_pathkeys = orderby_pathkeys;
6600 }
6601
6602 return window_pathkeys;
6603}
List * make_pathkeys_for_sortclauses_extended(PlannerInfo *root, List **sortclauses, List *tlist, bool remove_redundant, bool remove_group_rtindex, bool *sortable, bool set_ec_sortref)
Definition pathkeys.c:1381
References append_pathkeys(), Assert, ereport, errcode(), errdetail(), errmsg, ERROR, fb(), grouping_is_sortable(), make_pathkeys_for_sortclauses(), make_pathkeys_for_sortclauses_extended(), NIL, WindowClause::orderClause, WindowClause::partitionClause, and root.
Referenced by create_one_window_path(), and standard_qp_callback().
◆ make_sort_input_target()
|
static |
Definition at line 6672 of file planner.c.
6675{
6678 int ncols;
6690
6691 /* Shouldn't get here unless query has ORDER BY */
6693
6695
6696 /* Inspect tlist and collect per-column information */
6701
6702 i = 0;
6704 {
6706
6707 /*
6708 * If the column has a sortgroupref, assume it has to be evaluated
6709 * before sorting. Generally such columns would be ORDER BY, GROUP
6710 * BY, etc targets. One exception is columns that were removed from
6711 * GROUP BY by remove_useless_groupby_columns() ... but those would
6712 * only be Vars anyway. There don't seem to be any cases where it
6713 * would be worth the trouble to double-check.
6714 */
6716 {
6717 /*
6718 * Check for SRF or volatile functions. Check the SRF case first
6719 * because we must know whether we have any postponed SRFs.
6720 */
6723 {
6724 /* We'll decide below whether these are postponable */
6727 }
6729 {
6730 /* Unconditionally postpone */
6733 }
6734 else
6735 {
6736 /*
6737 * Else check the cost. XXX it's annoying to have to do this
6738 * when set_pathtarget_cost_width() just did it. Refactor to
6739 * allow sharing the work?
6740 */
6741 QualCost cost;
6742
6744
6745 /*
6746 * We arbitrarily define "expensive" as "more than 10X
6747 * cpu_operator_cost". Note this will take in any PL function
6748 * with default cost.
6749 */
6751 {
6754 }
6755 }
6756 }
6757 else
6758 {
6759 /* For sortgroupref cols, just check if any contain SRFs */
6761 parse->hasTargetSRFs &&
6764 }
6765
6766 i++;
6767 }
6768
6769 /*
6770 * We can postpone SRFs if we have some but none are in sortgroupref cols.
6771 */
6773
6774 /*
6775 * If we don't need a post-sort projection, just return final_target.
6776 */
6778 (have_expensive &&
6781
6782 /*
6783 * Report whether the post-sort projection will contain set-returning
6784 * functions. This is important because it affects whether the Sort can
6785 * rely on the query's LIMIT (if any) to bound the number of rows it needs
6786 * to return.
6787 */
6789
6790 /*
6791 * Construct the sort-input target, taking all non-postponable columns and
6792 * then adding Vars, PlaceHolderVars, Aggrefs, and WindowFuncs found in
6793 * the postponable ones.
6794 */
6797
6798 i = 0;
6800 {
6802
6805 else
6808
6809 i++;
6810 }
6811
6812 /*
6813 * Pull out all the Vars, Aggrefs, and WindowFuncs mentioned in
6814 * postponable columns, and add them to the sort-input target if not
6815 * already present. (Some might be there already.) We mustn't
6816 * deconstruct Aggrefs or WindowFuncs here, since the projection node
6817 * would be unable to recompute them.
6818 */
6820 PVC_INCLUDE_AGGREGATES |
6821 PVC_INCLUDE_WINDOWFUNCS |
6822 PVC_INCLUDE_PLACEHOLDERS);
6824
6825 /* clean up cruft */
6828
6829 /* XXX this represents even more redundant cost calculation ... */
6831}
void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
Definition costsize.c:4926
Definition pathnodes.h:119
References add_column_to_pathtarget(), add_new_columns_to_pathtarget(), Assert, contain_volatile_functions(), cost_qual_eval_node(), cpu_operator_cost, create_empty_pathtarget(), expression_returns_set(), fb(), get_pathtarget_sortgroupref, i, lappend(), lfirst, list_free(), list_length(), NIL, palloc0(), parse(), QualCost::per_tuple, pull_var_clause(), PVC_INCLUDE_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS, PVC_INCLUDE_WINDOWFUNCS, root, and set_pathtarget_cost_width().
Referenced by grouping_planner().
◆ make_window_input_target()
|
static |
Definition at line 6424 of file planner.c.
6427{
6434
6436
6437 /*
6438 * Collect the sortgroupref numbers of window PARTITION/ORDER BY clauses
6439 * into a bitmapset for convenient reference below.
6440 */
6443 {
6446
6448 {
6450
6452 }
6454 {
6456
6458 }
6459 }
6460
6461 /* Add in sortgroupref numbers of GROUP BY clauses, too */
6463 {
6465
6467 }
6468
6469 /*
6470 * Construct a target containing all the non-flattenable targetlist items,
6471 * and save aside the others for a moment.
6472 */
6475
6476 i = 0;
6478 {
6481
6482 /*
6483 * Don't want to deconstruct window clauses or GROUP BY items. (Note
6484 * that such items can't contain window functions, so it's okay to
6485 * compute them below the WindowAgg nodes.)
6486 */
6488 {
6489 /*
6490 * Don't want to deconstruct this value, so add it to the input
6491 * target as-is.
6492 */
6494 }
6495 else
6496 {
6497 /*
6498 * Column is to be flattened, so just remember the expression for
6499 * later call to pull_var_clause.
6500 */
6502 }
6503
6504 i++;
6505 }
6506
6507 /*
6508 * Pull out all the Vars and Aggrefs mentioned in flattenable columns, and
6509 * add them to the input target if not already present. (Some might be
6510 * there already because they're used directly as window/group clauses.)
6511 *
6512 * Note: it's essential to use PVC_INCLUDE_AGGREGATES here, so that any
6513 * Aggrefs are placed in the Agg node's tlist and not left to be computed
6514 * at higher levels. On the other hand, we should recurse into
6515 * WindowFuncs to make sure their input expressions are available.
6516 */
6518 PVC_INCLUDE_AGGREGATES |
6519 PVC_RECURSE_WINDOWFUNCS |
6520 PVC_INCLUDE_PLACEHOLDERS);
6522
6523 /* clean up cruft */
6526
6527 /* XXX this causes some redundant cost calculation ... */
6529}
References add_column_to_pathtarget(), add_new_columns_to_pathtarget(), Assert, bms_add_member(), bms_is_member(), create_empty_pathtarget(), fb(), get_pathtarget_sortgroupref, i, lappend(), lfirst, lfirst_node, list_free(), NIL, WindowClause::orderClause, WindowClause::partitionClause, pull_var_clause(), PVC_INCLUDE_AGGREGATES, PVC_INCLUDE_PLACEHOLDERS, PVC_RECURSE_WINDOWFUNCS, root, and set_pathtarget_cost_width().
Referenced by grouping_planner().
◆ mark_partial_aggref()
Definition at line 6009 of file planner.c.
6010{
6011 /* aggtranstype should be computed by this point */
6013 /* ... but aggsplit should still be as the parser left it */
6015
6016 /* Mark the Aggref with the intended partial-aggregation mode */
6017 agg->aggsplit = aggsplit;
6018
6019 /*
6020 * Adjust result type if needed. Normally, a partial aggregate returns
6021 * the aggregate's transition type; but if that's INTERNAL and we're
6022 * serializing, it returns BYTEA instead.
6023 */
6025 {
6028 else
6030 }
6031}
References AGGSPLIT_SIMPLE, Assert, DO_AGGSPLIT_SERIALIZE, DO_AGGSPLIT_SKIPFINAL, fb(), and OidIsValid.
Referenced by convert_combining_aggrefs(), create_rel_agg_info(), and make_partial_grouping_target().
◆ name_active_windows()
Definition at line 6304 of file planner.c.
6305{
6307 char newname[16];
6309
6311 {
6313
6314 /* Nothing to do if it has a name already. */
6315 if (wc->name)
6316 continue;
6317
6318 /* Select a name not currently present in the list. */
6319 for (;;)
6320 {
6322
6325 {
6327
6329 break; /* matched */
6330 }
6332 break; /* reached the end with no match */
6333 }
6334 wc->name = pstrdup(newname);
6335 }
6336}
References fb(), lfirst_node, pstrdup(), and snprintf.
Referenced by grouping_planner().
◆ optimize_window_clauses()
|
static |
Definition at line 6081 of file planner.c.
6082{
6085
6087 {
6091
6093
6094 /* skip any WindowClauses that have no WindowFuncs */
6096 continue;
6097
6099 {
6101 SupportRequestOptimizeWindowClause *res;
6104
6106
6107 /* Check if there's a support function for 'wfunc' */
6109 break; /* can't optimize this WindowClause */
6110
6112 req.window_clause = wc;
6113 req.window_func = wfunc;
6115
6116 /* call the support function */
6117 res = (SupportRequestOptimizeWindowClause *)
6120
6121 /*
6122 * Skip to next WindowClause if the support function does not
6123 * support this request type.
6124 */
6126 break;
6127
6128 /*
6129 * Save these frameOptions for the first WindowFunc for this
6130 * WindowClause.
6131 */
6134
6135 /*
6136 * On subsequent WindowFuncs, if the frameOptions are not the same
6137 * then we're unable to optimize the frameOptions for this
6138 * WindowClause.
6139 */
6141 break; /* skip to the next WindowClause, if any */
6142 }
6143
6144 /* adjust the frameOptions if all WindowFunc's agree that it's ok */
6146 {
6148
6149 /* apply the new frame options */
6151
6152 /*
6153 * We now check to see if changing the frameOptions has caused
6154 * this WindowClause to be a duplicate of some other WindowClause.
6155 * This can only happen if we have multiple WindowClauses, so
6156 * don't bother if there's only 1.
6157 */
6159 continue;
6160
6161 /*
6162 * Do the duplicate check and reuse the existing WindowClause if
6163 * we find a duplicate.
6164 */
6166 {
6168
6169 /* skip over the WindowClause we're currently editing */
6171 continue;
6172
6173 /*
6174 * Perform the same duplicate check that is done in
6175 * transformWindowFuncCall.
6176 */
6182 {
6184
6185 /*
6186 * Now move each WindowFunc in 'wc' into 'existing_wc'.
6187 * This required adjusting each WindowFunc's winref and
6188 * moving the WindowFuncs in 'wc' to the list of
6189 * WindowFuncs in 'existing_wc'.
6190 */
6192 {
6194
6196 }
6197
6198 /* move list items */
6199 wflists->windowFuncs[existing_wc->winref] = list_concat(wflists->windowFuncs[existing_wc->winref],
6202
6203 /*
6204 * transformWindowFuncCall() should have made sure there
6205 * are no other duplicates, so we needn't bother looking
6206 * any further.
6207 */
6208 break;
6209 }
6210 }
6211 }
6212 }
6213}
References Assert, DatumGetPointer(), WindowClause::endOffset, equal(), fb(), foreach_current_index, WindowClause::frameOptions, SupportRequestOptimizeWindowClause::frameOptions, get_func_support(), lfirst_node, list_concat(), list_length(), NIL, OidFunctionCall1, OidIsValid, WindowClause::orderClause, WindowClause::partitionClause, PointerGetDatum, root, WindowClause::startOffset, WindowFunc::winfnoid, WindowClause::winref, and WindowFunc::winref.
Referenced by grouping_planner().
◆ plan_cluster_use_sort()
Definition at line 7090 of file planner.c.
7091{
7093 Query *query;
7094 PlannerGlobal *glob;
7096 RelOptInfo *rel;
7097 IndexOptInfo *indexInfo;
7104
7105 /* We can short-circuit the cost comparison if indexscans are disabled */
7107 return true; /* use sort */
7108
7109 /* Set up mostly-dummy planner state */
7112
7114
7116 root->parse = query;
7117 root->glob = glob;
7118 root->query_level = 1;
7120 root->wt_param_id = -1;
7122
7123 /* Build a minimal RTE for the rel */
7126 rte->relid = tableOid;
7134
7135 /* Set up RTE/RelOptInfo arrays */
7137
7138 /* Build RelOptInfo */
7140
7141 /* Locate IndexOptInfo for the target index */
7142 indexInfo = NULL;
7144 {
7147 break;
7148 }
7149
7150 /*
7151 * It's possible that get_relation_info did not generate an IndexOptInfo
7152 * for the desired index; this could happen if it's not yet reached its
7153 * indcheckxmin usability horizon, or if it's a system index and we're
7154 * ignoring system indexes. In such cases we should tell CLUSTER to not
7155 * trust the index contents but use seqscan-and-sort.
7156 */
7158 return true; /* use sort */
7159
7160 /*
7161 * Rather than doing all the pushups that would be needed to use
7162 * set_baserel_size_estimates, just do a quick hack for rows and width.
7163 */
7166
7168
7169 /*
7170 * Determine eval cost of the index expressions, if any. We need to
7171 * charge twice that amount for each tuple comparison that happens during
7172 * the sort, since tuplesort.c will have to re-evaluate the index
7173 * expressions each time. (XXX that's pretty inefficient...)
7174 */
7177
7178 /* Estimate the cost of seq scan + sort */
7181 seqScanPath->disabled_nodes,
7184
7185 /* Estimate the cost of index scan */
7190
7192}
void cost_sort(Path *path, PlannerInfo *root, List *pathkeys, int input_disabled_nodes, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
Definition costsize.c:2201
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
Definition costsize.c:4900
RTEPermissionInfo * addRTEPermissionInfo(List **rteperminfos, RangeTblEntry *rte)
Definition parse_relation.c:4051
IndexPath * create_index_path(PlannerInfo *root, IndexOptInfo *index, List *indexclauses, List *indexorderbys, List *indexorderbycols, List *pathkeys, ScanDirection indexscandir, bool indexonly, Relids required_outer, double loop_count, bool partial_path)
Definition pathnode.c:1092
Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
Definition pathnode.c:1026
int32 get_relation_data_width(Oid relid, int32 *attr_widths)
Definition plancat.c:1472
RelOptInfo * build_simple_rel(PlannerInfo *root, int relid, RelOptInfo *parent)
Definition relnode.c:212
Definition pathnodes.h:1347
Definition pathnodes.h:2054
Definition pathnodes.h:1562
Definition parsenodes.h:1141
References AccessShareLock, addRTEPermissionInfo(), build_simple_rel(), CMD_SELECT, Query::commandType, cost_qual_eval(), cost_sort(), create_index_path(), create_seqscan_path(), CurrentMemoryContext, enable_indexscan, fb(), ForwardScanDirection, get_relation_data_width(), RelOptInfo::indexlist, IndexOptInfo::indexoid, lfirst_node, list_make1, maintenance_work_mem, makeNode, NIL, RelOptInfo::pages, RelOptInfo::reltarget, root, RelOptInfo::rows, Query::rtable, RTE_RELATION, setup_simple_rel_arrays(), RelOptInfo::tuples, and PathTarget::width.
Referenced by copy_table_data().
◆ plan_create_index_workers()
Definition at line 7212 of file planner.c.
7213{
7215 Query *query;
7216 PlannerGlobal *glob;
7218 Relation heap;
7220 RelOptInfo *rel;
7221 int parallel_workers;
7223 double reltuples;
7224 double allvisfrac;
7225
7226 /*
7227 * We don't allow performing parallel operation in standalone backend or
7228 * when parallelism is disabled.
7229 */
7231 return 0;
7232
7233 /* Set up largely-dummy planner state */
7236
7238
7240 root->parse = query;
7241 root->glob = glob;
7242 root->query_level = 1;
7244 root->wt_param_id = -1;
7246
7247 /*
7248 * Build a minimal RTE.
7249 *
7250 * Mark the RTE with inh = true. This is a kludge to prevent
7251 * get_relation_info() from fetching index info, which is necessary
7252 * because it does not expect that any IndexOptInfo is currently
7253 * undergoing REINDEX.
7254 */
7257 rte->relid = tableOid;
7265
7266 /* Set up RTE/RelOptInfo arrays */
7268
7269 /* Build RelOptInfo */
7271
7272 /* Rels are assumed already locked by the caller */
7275
7276 /*
7277 * Determine if it's safe to proceed.
7278 *
7279 * Currently, parallel workers can't access the leader's temporary tables.
7280 * Furthermore, any index predicate or index expressions must be parallel
7281 * safe.
7282 */
7286 {
7287 parallel_workers = 0;
7288 goto done;
7289 }
7290
7291 /*
7292 * If parallel_workers storage parameter is set for the table, accept that
7293 * as the number of parallel worker processes to launch (though still cap
7294 * at max_parallel_maintenance_workers). Note that we deliberately do not
7295 * consider any other factor when parallel_workers is set. (e.g., memory
7296 * use by workers.)
7297 */
7299 {
7302 goto done;
7303 }
7304
7305 /*
7306 * Estimate heap relation size ourselves, since rel->pages cannot be
7307 * trusted (heap RTE was marked as inheritance parent)
7308 */
7310
7311 /*
7312 * Determine number of workers to scan the heap relation using generic
7313 * model
7314 */
7317
7318 /*
7319 * Cap workers based on available maintenance_work_mem as needed.
7320 *
7321 * Note that each tuplesort participant receives an even share of the
7322 * total maintenance_work_mem budget. Aim to leave participants
7323 * (including the leader as a participant) with no less than 32MB of
7324 * memory. This leaves cases where maintenance_work_mem is set to 64MB
7325 * immediately past the threshold of being capable of launching a single
7326 * parallel worker to sort.
7327 */
7328 while (parallel_workers > 0 &&
7329 maintenance_work_mem / (parallel_workers + 1) < 32 * 1024)
7330 parallel_workers--;
7331
7332done:
7335
7336 return parallel_workers;
7337}
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition allpaths.c:4973
void estimate_rel_size(Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac)
Definition plancat.c:1305
List * RelationGetIndexPredicate(Relation relation)
Definition relcache.c:5220
List * RelationGetIndexExpressions(Relation relation)
Definition relcache.c:5107
Definition rel.h:56
References AccessShareLock, addRTEPermissionInfo(), build_simple_rel(), CMD_SELECT, Query::commandType, compute_parallel_worker(), CurrentMemoryContext, estimate_rel_size(), fb(), index_close(), index_open(), is_parallel_safe(), IsUnderPostmaster, list_make1, maintenance_work_mem, makeNode, max_parallel_maintenance_workers, Min, NoLock, RelationData::rd_rel, RelOptInfo::rel_parallel_workers, RelationGetIndexExpressions(), RelationGetIndexPredicate(), root, Query::rtable, RTE_RELATION, setup_simple_rel_arrays(), table_close(), and table_open().
Referenced by index_build().
◆ planner()
| PlannedStmt * planner | ( | Query * | parse, |
| const char * | query_string, | ||
| int | cursorOptions, | ||
| ParamListInfo | boundParams, | ||
| ExplainState * | es | ||
| ) |
Definition at line 328 of file planner.c.
330{
332
335 boundParams, es);
336 else
338 boundParams, es);
339
341
343}
void pgstat_report_plan_id(int64 plan_id, bool force)
Definition backend_status.c:690
PlannedStmt * standard_planner(Query *parse, const char *query_string, int cursorOptions, ParamListInfo boundParams, ExplainState *es)
Definition planner.c:346
Definition plannodes.h:60
References parse(), pgstat_report_plan_id(), planner_hook, result, and standard_planner().
Referenced by pg_plan_query(), and test_plan_advice_advisor().
◆ postprocess_setop_tlist()
Definition at line 6044 of file planner.c.
6045{
6046 ListCell *l;
6048
6050 {
6053
6054 /* ignore resjunk columns in setop result */
6056 continue;
6057
6065 }
6069}
References Assert, elog, ERROR, fb(), lfirst_node, list_head(), and lnext().
Referenced by grouping_planner().
◆ preprocess_expression()
|
static |
Definition at line 1429 of file planner.c.
1430{
1431 /*
1432 * Fall out quickly if expression is empty. This occurs often enough to
1433 * be worth checking. Note that null->null is the correct conversion for
1434 * implicit-AND result format, too.
1435 */
1438
1439 /*
1440 * If the query has any join RTEs, replace join alias variables with
1441 * base-relation variables. We must do this first, since any expressions
1442 * we may extract from the joinaliasvars lists have not been preprocessed.
1443 * For example, if we did this after sublink processing, sublinks expanded
1444 * out from join aliases would not get processed. But we can skip this in
1445 * non-lateral RTE functions, VALUES lists, and TABLESAMPLE clauses, since
1446 * they can't contain any Vars of the current query level.
1447 */
1449 !(kind == EXPRKIND_RTFUNC ||
1450 kind == EXPRKIND_VALUES ||
1451 kind == EXPRKIND_TABLESAMPLE ||
1452 kind == EXPRKIND_TABLEFUNC))
1454
1455 /*
1456 * Simplify constant expressions. For function RTEs, this was already
1457 * done by preprocess_function_rtes. (But note we must do it again for
1458 * EXPRKIND_RTFUNC_LATERAL, because those might by now contain
1459 * un-simplified subexpressions inserted by flattening of subqueries or
1460 * join alias variables.)
1461 *
1462 * Note: an essential effect of this is to convert named-argument function
1463 * calls to positional notation and insert the current actual values of
1464 * any default arguments for functions. To ensure that happens, we *must*
1465 * process all expressions here. Previous PG versions sometimes skipped
1466 * const-simplification if it didn't seem worth the trouble, but we can't
1467 * do that anymore.
1468 *
1469 * Note: this also flattens nested AND and OR expressions into N-argument
1470 * form. All processing of a qual expression after this point must be
1471 * careful to maintain AND/OR flatness --- that is, do not generate a tree
1472 * with AND directly under AND, nor OR directly under OR.
1473 */
1476
1477 /*
1478 * If it's a qual or havingQual, canonicalize it.
1479 */
1481 {
1483
1484#ifdef OPTIMIZER_DEBUG
1486 pprint(expr);
1487#endif
1488 }
1489
1490 /*
1491 * Check for ANY ScalarArrayOpExpr with Const arrays and set the
1492 * hashfuncid of any that might execute more quickly by using hash lookups
1493 * instead of a linear search.
1494 */
1496 {
1497 convert_saop_to_hashed_saop(expr);
1498 }
1499
1500 /* Expand SubLinks to SubPlans */
1503
1504 /*
1505 * XXX do not insert anything here unless you have grokked the comments in
1506 * SS_replace_correlation_vars ...
1507 */
1508
1509 /* Replace uplevel vars with Param nodes (this IS possible in VALUES) */
1512
1513 /*
1514 * If it's a qual or havingQual, convert it to implicit-AND format. (We
1515 * don't want to do this before eval_const_expressions, since the latter
1516 * would be unable to simplify a top-level AND correctly. Also,
1517 * SS_process_sublinks expects explicit-AND format.)
1518 */
1521
1522 return expr;
1523}
Node * SS_process_sublinks(PlannerInfo *root, Node *expr, bool isQual)
Definition subselect.c:2209
Node * SS_replace_correlation_vars(PlannerInfo *root, Node *expr)
Definition subselect.c:2154
Node * flatten_join_alias_vars(PlannerInfo *root, Query *query, Node *node)
Definition var.c:781
References canonicalize_qual(), convert_saop_to_hashed_saop(), eval_const_expressions(), EXPRKIND_QUAL, EXPRKIND_RTFUNC, EXPRKIND_TABLEFUNC, EXPRKIND_TABLESAMPLE, EXPRKIND_TARGET, EXPRKIND_VALUES, fb(), flatten_join_alias_vars(), make_ands_implicit(), pprint(), printf, root, SS_process_sublinks(), and SS_replace_correlation_vars().
Referenced by preprocess_phv_expression(), preprocess_qual_conditions(), and subquery_planner().
◆ preprocess_groupclause()
|
static |
Definition at line 3098 of file planner.c.
3099{
3104
3105 /* For grouping sets, we need to force the ordering */
3106 if (force)
3107 {
3109 {
3112
3114 }
3115
3117 }
3118
3119 /* If no ORDER BY, nothing useful to do here */
3122
3123 /*
3124 * Scan the ORDER BY clause and construct a list of matching GROUP BY
3125 * items, but only as far as we can make a matching prefix.
3126 *
3127 * This code assumes that the sortClause contains no duplicate items.
3128 */
3130 {
3132
3134 {
3136
3138 {
3140 break;
3141 }
3142 }
3144 break; /* no match, so stop scanning */
3145 }
3146
3147
3148 /* If no match at all, no point in reordering GROUP BY */
3151
3152 /*
3153 * Add any remaining GROUP BY items to the new list. We don't require a
3154 * complete match, because even partial match allows ORDER BY to be
3155 * implemented using incremental sort. Also, give up if there are any
3156 * non-sortable GROUP BY items, since then there's no hope anyway.
3157 */
3159 {
3161
3163 continue; /* it matched an ORDER BY item */
3167 }
3168
3169 /* Success --- install the rearranged GROUP BY list */
3172}
SortGroupClause * get_sortgroupref_clause(Index sortref, List *clauses)
Definition tlist.c:431
References Assert, equal(), fb(), get_sortgroupref_clause(), lappend(), lfirst_int, lfirst_node, list_copy(), list_length(), list_member_ptr(), NIL, OidIsValid, parse(), and root.
Referenced by consider_groupingsets_paths(), grouping_planner(), and preprocess_grouping_sets().
◆ preprocess_grouping_sets()
|
static |
Definition at line 2452 of file planner.c.
2453{
2459
2460 /*
2461 * We don't currently make any attempt to optimize the groupClause when
2462 * there are grouping sets, so just duplicate it in processed_groupClause.
2463 */
2465
2466 /* Detect unhashable and unsortable grouping expressions */
2471
2473 {
2475
2477 {
2480
2483
2486
2489 }
2490 }
2491
2492 /* Allocate workspace array for remapping */
2494
2495 /*
2496 * If we have any unsortable sets, we must extract them before trying to
2497 * prepare rollups. Unsortable sets don't go through
2498 * reorder_grouping_sets, so we must apply the GroupingSetData annotation
2499 * here.
2500 */
2502 {
2505
2507 {
2509
2511 {
2513
2516
2517 /*
2518 * We must enforce here that an unsortable set is hashable;
2519 * later code assumes this. Parse analysis only checks that
2520 * every individual column is either hashable or sortable.
2521 *
2522 * Note that passing this test doesn't guarantee we can
2523 * generate a plan; there might be other showstoppers.
2524 */
2530 }
2531 else
2533 }
2534
2537 else
2539 }
2540 else
2542
2544 {
2548
2549 /*
2550 * Reorder the current list of grouping sets into correct prefix
2551 * order. If only one aggregation pass is needed, try to make the
2552 * list match the ORDER BY clause; if more than one pass is needed, we
2553 * don't bother with that.
2554 *
2555 * Note that this reorders the sets from smallest-member-first to
2556 * largest-member-first, and applies the GroupingSetData annotations,
2557 * though the data will be filled in later.
2558 */
2561 ? parse->sortClause
2562 : NIL));
2563
2564 /*
2565 * Get the initial (and therefore largest) grouping set.
2566 */
2568
2569 /*
2570 * Order the groupClause appropriately. If the first grouping set is
2571 * empty, then the groupClause must also be empty; otherwise we have
2572 * to force the groupClause to match that grouping set's order.
2573 *
2574 * (The first grouping set can be empty even though parse->groupClause
2575 * is not empty only if all non-empty grouping sets are unsortable.
2576 * The groupClauses for hashed grouping sets are built later on.)
2577 */
2580 else
2582
2583 /*
2584 * Is it hashable? We pretend empty sets are hashable even though we
2585 * actually force them not to be hashed later. But don't bother if
2586 * there's nothing but empty sets (since in that case we can't hash
2587 * anything).
2588 */
2591 {
2594 }
2595
2596 /*
2597 * Now that we've pinned down an order for the groupClause for this
2598 * list of grouping sets, we need to remap the entries in the grouping
2599 * sets from sortgrouprefs to plain indices (0-based) into the
2600 * groupClause for this collection of grouping sets. We keep the
2601 * original form for later use, though.
2602 */
2604 current_sets,
2605 gd->tleref_to_colnum_map);
2607
2609 }
2610
2612 {
2613 /*
2614 * We have not yet pinned down a groupclause for this, but we will
2615 * need index-based lists for estimation purposes. Construct
2616 * hash_sets_idx based on the entire original groupclause for now.
2617 */
2619 gd->unsortable_sets,
2620 gd->tleref_to_colnum_map);
2622 }
2623
2625}
static List * reorder_grouping_sets(List *groupingSets, List *sortclause)
Definition planner.c:3406
References bms_add_member(), bms_is_empty, bms_overlap_list(), ereport, errcode(), errdetail(), errmsg, ERROR, extract_rollup_sets(), fb(), lappend(), lfirst, lfirst_node, linitial_node, list_length(), makeNode, NIL, OidIsValid, palloc(), palloc0_object, parse(), preprocess_groupclause(), remap_to_groupclause_idx(), reorder_grouping_sets(), and root.
Referenced by grouping_planner().
◆ preprocess_limit()
|
static |
Definition at line 2847 of file planner.c.
2849{
2853
2854 /* Should not be called unless LIMIT or OFFSET */
2856
2857 /*
2858 * Try to obtain the clause values. We use estimate_expression_value
2859 * primarily because it can sometimes do something useful with Params.
2860 */
2862 {
2865 {
2867 {
2868 /* NULL indicates LIMIT ALL, ie, no limit */
2869 *count_est = 0; /* treat as not present */
2870 }
2871 else
2872 {
2874 if (*count_est <= 0)
2875 *count_est = 1; /* force to at least 1 */
2876 }
2877 }
2878 else
2879 *count_est = -1; /* can't estimate */
2880 }
2881 else
2882 *count_est = 0; /* not present */
2883
2885 {
2888 {
2890 {
2891 /* Treat NULL as no offset; the executor will too */
2892 *offset_est = 0; /* treat as not present */
2893 }
2894 else
2895 {
2897 if (*offset_est < 0)
2898 *offset_est = 0; /* treat as not present */
2899 }
2900 }
2901 else
2902 *offset_est = -1; /* can't estimate */
2903 }
2904 else
2905 *offset_est = 0; /* not present */
2906
2907 if (*count_est != 0)
2908 {
2909 /*
2910 * A LIMIT clause limits the absolute number of tuples returned.
2911 * However, if it's not a constant LIMIT then we have to guess; for
2912 * lack of a better idea, assume 10% of the plan's result is wanted.
2913 */
2914 if (*count_est < 0 || *offset_est < 0)
2915 {
2916 /* LIMIT or OFFSET is an expression ... punt ... */
2917 limit_fraction = 0.10;
2918 }
2919 else
2920 {
2921 /* LIMIT (plus OFFSET, if any) is max number of tuples needed */
2923 }
2924
2925 /*
2926 * If we have absolute limits from both caller and LIMIT, use the
2927 * smaller value; likewise if they are both fractional. If one is
2928 * fractional and the other absolute, we can't easily determine which
2929 * is smaller, but we use the heuristic that the absolute will usually
2930 * be smaller.
2931 */
2932 if (tuple_fraction >= 1.0)
2933 {
2935 {
2936 /* both absolute */
2938 }
2939 else
2940 {
2941 /* caller absolute, limit fractional; use caller's value */
2942 }
2943 }
2944 else if (tuple_fraction > 0.0)
2945 {
2947 {
2948 /* caller fractional, limit absolute; use limit */
2949 tuple_fraction = limit_fraction;
2950 }
2951 else
2952 {
2953 /* both fractional */
2955 }
2956 }
2957 else
2958 {
2959 /* no info from caller, just use limit */
2960 tuple_fraction = limit_fraction;
2961 }
2962 }
2963 else if (*offset_est != 0 && tuple_fraction > 0.0)
2964 {
2965 /*
2966 * We have an OFFSET but no LIMIT. This acts entirely differently
2967 * from the LIMIT case: here, we need to increase rather than decrease
2968 * the caller's tuple_fraction, because the OFFSET acts to cause more
2969 * tuples to be fetched instead of fewer. This only matters if we got
2970 * a tuple_fraction > 0, however.
2971 *
2972 * As above, use 10% if OFFSET is present but unestimatable.
2973 */
2974 if (*offset_est < 0)
2975 limit_fraction = 0.10;
2976 else
2978
2979 /*
2980 * If we have absolute counts from both caller and OFFSET, add them
2981 * together; likewise if they are both fractional. If one is
2982 * fractional and the other absolute, we want to take the larger, and
2983 * we heuristically assume that's the fractional one.
2984 */
2985 if (tuple_fraction >= 1.0)
2986 {
2988 {
2989 /* both absolute, so add them together */
2990 tuple_fraction += limit_fraction;
2991 }
2992 else
2993 {
2994 /* caller absolute, limit fractional; use limit */
2995 tuple_fraction = limit_fraction;
2996 }
2997 }
2998 else
2999 {
3001 {
3002 /* caller fractional, limit absolute; use caller's value */
3003 }
3004 else
3005 {
3006 /* both fractional, so add them together */
3007 tuple_fraction += limit_fraction;
3008 if (tuple_fraction >= 1.0)
3009 tuple_fraction = 0.0; /* assume fetch all */
3010 }
3011 }
3012 }
3013
3014 return tuple_fraction;
3015}
Node * estimate_expression_value(PlannerInfo *root, Node *node)
Definition clauses.c:2660
References Assert, DatumGetInt64(), estimate_expression_value(), fb(), IsA, Min, parse(), and root.
Referenced by grouping_planner().
◆ preprocess_phv_expression()
| Expr * preprocess_phv_expression | ( | PlannerInfo * | root, |
| Expr * | expr | ||
| ) |
Definition at line 1671 of file planner.c.
1672{
1674}
static Node * preprocess_expression(PlannerInfo *root, Node *expr, int kind)
Definition planner.c:1429
References EXPRKIND_PHV, preprocess_expression(), and root.
Referenced by extract_lateral_references().
◆ preprocess_qual_conditions()
|
static |
Definition at line 1531 of file planner.c.
1532{
1534 return;
1536 {
1537 /* nothing to do here */
1538 }
1540 {
1542 ListCell *l;
1543
1546
1548 }
1550 {
1552
1555
1557 }
1558 else
1561}
static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode)
Definition planner.c:1531
Definition primnodes.h:2375
Definition primnodes.h:2347
Definition primnodes.h:2313
References elog, ERROR, EXPRKIND_QUAL, fb(), FromExpr::fromlist, IsA, j, lfirst, nodeTag, preprocess_expression(), preprocess_qual_conditions(), FromExpr::quals, and root.
Referenced by preprocess_qual_conditions(), and subquery_planner().
◆ preprocess_rowmarks()
|
static |
Definition at line 2669 of file planner.c.
2670{
2672 Bitmapset *rels;
2674 ListCell *l;
2676
2678 {
2679 /*
2680 * We've got trouble if FOR [KEY] UPDATE/SHARE appears inside
2681 * grouping, since grouping renders a reference to individual tuple
2682 * CTIDs invalid. This is also checked at parse time, but that's
2683 * insufficient because of rule substitution, query pullup, etc.
2684 */
2686 parse->rowMarks)->strength);
2687 }
2688 else
2689 {
2690 /*
2691 * We only need rowmarks for UPDATE, DELETE, MERGE, or FOR [KEY]
2692 * UPDATE/SHARE.
2693 */
2697 return;
2698 }
2699
2700 /*
2701 * We need to have rowmarks for all base relations except the target. We
2702 * make a bitmapset of all base rels and then remove the items we don't
2703 * need or have FOR [KEY] UPDATE/SHARE marks for.
2704 */
2708
2709 /*
2710 * Convert RowMarkClauses to PlanRowMark representation.
2711 */
2714 {
2718
2719 /*
2720 * Currently, it is syntactically impossible to have FOR UPDATE et al
2721 * applied to an update/delete target rel. If that ever becomes
2722 * possible, we should drop the target from the PlanRowMark list.
2723 */
2725
2726 /*
2727 * Ignore RowMarkClauses for subqueries; they aren't real tables and
2728 * can't support true locking. Subqueries that got flattened into the
2729 * main query should be ignored completely. Any that didn't will get
2730 * ROW_MARK_COPY items in the next loop.
2731 */
2733 continue;
2734
2736
2745
2747 }
2748
2749 /*
2750 * Now, add rowmarks for any non-target, non-locked base relations.
2751 */
2752 i = 0;
2754 {
2757
2758 i++;
2760 continue;
2761
2770
2772 }
2773
2775}
void CheckSelectLocking(Query *qry, LockClauseStrength strength)
Definition analyze.c:3742
RowMarkType select_rowmark_type(RangeTblEntry *rte, LockClauseStrength strength)
Definition planner.c:2781
Relids get_relids_in_jointree(Node *jtnode, bool include_outer_joins, bool include_inner_joins)
Definition prepjointree.c:4533
Definition plannodes.h:1606
References Assert, bms_del_member(), bms_is_member(), CheckSelectLocking(), CMD_DELETE, CMD_MERGE, CMD_UPDATE, fb(), get_relids_in_jointree(), i, lappend(), LCS_NONE, lfirst_node, linitial_node, LockWaitBlock, makeNode, NIL, parse(), root, rt_fetch, RTE_RELATION, RowMarkClause::rti, select_rowmark_type(), RowMarkClause::strength, and RowMarkClause::waitPolicy.
Referenced by subquery_planner().
◆ remap_to_groupclause_idx()
|
static |
Definition at line 2632 of file planner.c.
2635{
2639
2641 {
2643
2645 }
2646
2648 {
2652
2654 {
2656 }
2657
2659 }
2660
2662}
References fb(), lappend(), lappend_int(), lfirst_int, lfirst_node, NIL, and result.
Referenced by consider_groupingsets_paths(), and preprocess_grouping_sets().
◆ reorder_grouping_sets()
Definition at line 3406 of file planner.c.
3407{
3411
3413 {
3417
3420 {
3423
3425 {
3428 }
3429 else
3430 {
3431 /* diverged from the sortclause; give up on it */
3433 break;
3434 }
3435 }
3436
3438
3441 }
3442
3443 list_free(previous);
3444
3446}
List * list_difference_int(const List *list1, const List *list2)
Definition list.c:1288
References fb(), lappend_int(), lcons(), lfirst, list_concat(), list_copy(), list_delete_int(), list_difference_int(), list_free(), list_length(), list_member_int(), list_nth(), makeNode, NIL, and result.
Referenced by preprocess_grouping_sets().
◆ select_active_windows()
|
static |
Definition at line 6221 of file planner.c.
6222{
6228 list_length(windowClause));
6229
6230 /* First, construct an array of the active windows */
6232 {
6234
6235 /* It's only active if wflists shows some related WindowFuncs */
6238 continue;
6239
6241
6242 /*
6243 * For sorting, we want the list of partition keys followed by the
6244 * list of sort keys. But pathkeys construction will remove duplicates
6245 * between the two, so we can as well (even though we can't detect all
6246 * of the duplicates, since some may come from ECs - that might mean
6247 * we miss optimization chances here). We must, however, ensure that
6248 * the order of entries is preserved with respect to the ones we do
6249 * keep.
6250 *
6251 * partitionClause and orderClause had their own duplicates removed in
6252 * parse analysis, so we're only concerned here with removing
6253 * orderClause entries that also appear in partitionClause.
6254 */
6257 wc->orderClause);
6258 nActive++;
6259 }
6260
6261 /*
6262 * Sort active windows by their partitioning/ordering clauses, ignoring
6263 * any framing clauses, so that the windows that need the same sorting are
6264 * adjacent in the list. When we come to generate paths, this will avoid
6265 * inserting additional Sort nodes.
6266 *
6267 * This is how we implement a specific requirement from the SQL standard,
6268 * which says that when two or more windows are order-equivalent (i.e.
6269 * have matching partition and order clauses, even if their names or
6270 * framing clauses differ), then all peer rows must be presented in the
6271 * same order in all of them. If we allowed multiple sort nodes for such
6272 * cases, we'd risk having the peer rows end up in different orders in
6273 * equivalent windows due to sort instability. (See General Rule 4 of
6274 * <window clause> in SQL2008 - SQL2016.)
6275 *
6276 * Additionally, if the entire list of clauses of one window is a prefix
6277 * of another, put first the window with stronger sorting requirements.
6278 * This way we will first sort for stronger window, and won't have to sort
6279 * again for the weaker one.
6280 */
6282
6283 /* build ordered list of the original WindowClause nodes */
6286
6288
6290}
static int common_prefix_cmp(const void *a, const void *b)
Definition planner.c:6355
References Assert, common_prefix_cmp(), fb(), i, lappend(), lfirst_node, list_concat_unique(), list_copy(), list_length(), NIL, WindowClause::orderClause, palloc_array, WindowClause::partitionClause, pfree(), qsort, result, root, and WindowClause::winref.
Referenced by grouping_planner().
◆ select_rowmark_type()
| RowMarkType select_rowmark_type | ( | RangeTblEntry * | rte, |
| LockClauseStrength | strength | ||
| ) |
Definition at line 2781 of file planner.c.
2782{
2784 {
2785 /* If it's not a table at all, use ROW_MARK_COPY */
2787 }
2789 {
2790 /* Let the FDW select the rowmark type, if it wants to */
2792
2795 /* Otherwise, use ROW_MARK_COPY by default */
2797 }
2798 else
2799 {
2800 /* Regular table, apply the appropriate lock type */
2801 switch (strength)
2802 {
2804
2805 /*
2806 * We don't need a tuple lock, only the ability to re-fetch
2807 * the row.
2808 */
2810 break;
2813 break;
2816 break;
2819 break;
2822 break;
2823 }
2826 }
2827}
GetForeignRowMarkType_function GetForeignRowMarkType
Definition fdwapi.h:251
References elog, ERROR, fb(), GetFdwRoutineByRelId(), FdwRoutine::GetForeignRowMarkType, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, LCS_NONE, ROW_MARK_COPY, ROW_MARK_EXCLUSIVE, ROW_MARK_KEYSHARE, ROW_MARK_NOKEYEXCLUSIVE, ROW_MARK_REFERENCE, ROW_MARK_SHARE, and RTE_RELATION.
Referenced by expand_single_inheritance_child(), and preprocess_rowmarks().
◆ standard_planner()
| PlannedStmt * standard_planner | ( | Query * | parse, |
| const char * | query_string, | ||
| int | cursorOptions, | ||
| ParamListInfo | boundParams, | ||
| ExplainState * | es | ||
| ) |
Definition at line 346 of file planner.c.
348{
350 PlannerGlobal *glob;
351 double tuple_fraction;
357 *lr,
358 *lc;
359
360 /*
361 * Set up global state for this planner invocation. This data is needed
362 * across all levels of sub-Query that might exist in the given command,
363 * so we keep it in a separate struct that's linked to by each per-Query
364 * PlannerInfo.
365 */
367
368 glob->boundParams = boundParams;
371 glob->subroots = NIL;
384 glob->lastPHId = 0;
385 glob->lastRowMarkId = 0;
386 glob->lastPlanNodeId = 0;
389 glob->partition_directory = NULL;
390 glob->rel_notnullatts_hash = NULL;
391
392 /*
393 * Assess whether it's feasible to use parallel mode for this query. We
394 * can't do this in a standalone backend, or if the command will try to
395 * modify any data, or if this is a cursor operation, or if GUCs are set
396 * to values that don't permit parallelism, or if parallel-unsafe
397 * functions are present in the query tree.
398 *
399 * (Note that we do allow CREATE TABLE AS, SELECT INTO, and CREATE
400 * MATERIALIZED VIEW to use parallel plans, but this is safe only because
401 * the command is writing into a completely new table which workers won't
402 * be able to see. If the workers could see the table, the fact that
403 * group locking would cause them to ignore the leader's heavyweight GIN
404 * page locks would make this unsafe. We'll have to fix that somehow if
405 * we want to allow parallel inserts in general; updates and deletes have
406 * additional problems especially around combo CIDs.)
407 *
408 * For now, we don't try to use parallel mode if we're running inside a
409 * parallel worker. We might eventually be able to relax this
410 * restriction, but for now it seems best not to have parallel workers
411 * trying to create their own parallel workers.
412 */
414 IsUnderPostmaster &&
416 !parse->hasModifyingCTE &&
417 max_parallel_workers_per_gather > 0 &&
418 !IsParallelWorker())
419 {
420 /* all the cheap tests pass, so scan the query tree */
423 }
424 else
425 {
426 /* skip the query tree scan, just assume it's unsafe */
429 }
430
431 /*
432 * glob->parallelModeNeeded is normally set to false here and changed to
433 * true during plan creation if a Gather or Gather Merge plan is actually
434 * created (cf. create_gather_plan, create_gather_merge_plan).
435 *
436 * However, if debug_parallel_query = on or debug_parallel_query =
437 * regress, then we impose parallel mode whenever it's safe to do so, even
438 * if the final plan doesn't use parallelism. It's not safe to do so if
439 * the query contains anything parallel-unsafe; parallelModeOK will be
440 * false in that case. Note that parallelModeOK can't change after this
441 * point. Otherwise, everything in the query is either parallel-safe or
442 * parallel-restricted, and in either case it should be OK to impose
443 * parallel-mode restrictions. If that ends up breaking something, then
444 * either some function the user included in the query is incorrectly
445 * labeled as parallel-safe or parallel-restricted when in reality it's
446 * parallel-unsafe, or else the query planner itself has a bug.
447 */
450
451 /* Determine what fraction of the plan is likely to be scanned */
453 {
454 /*
455 * We have no real idea how many tuples the user will ultimately FETCH
456 * from a cursor, but it is often the case that he doesn't want 'em
457 * all, or would prefer a fast-start plan anyway so that he can
458 * process some of the tuples sooner. Use a GUC parameter to decide
459 * what fraction to optimize for.
460 */
461 tuple_fraction = cursor_tuple_fraction;
462
463 /*
464 * We document cursor_tuple_fraction as simply being a fraction, which
465 * means the edge cases 0 and 1 have to be treated specially here. We
466 * convert 1 to 0 ("all the tuples") and 0 to a very small fraction.
467 */
468 if (tuple_fraction >= 1.0)
469 tuple_fraction = 0.0;
470 else if (tuple_fraction <= 0.0)
471 tuple_fraction = 1e-10;
472 }
473 else
474 {
475 /* Default assumption is we need all the tuples */
476 tuple_fraction = 0.0;
477 }
478
479 /*
480 * Compute the initial path generation strategy mask.
481 *
482 * Some strategies, such as PGS_FOREIGNJOIN, have no corresponding enable_*
483 * GUC, and so the corresponding bits are always set in the default
484 * strategy mask.
485 *
486 * It may seem surprising that enable_indexscan sets both PGS_INDEXSCAN
487 * and PGS_INDEXONLYSCAN. However, the historical behavior of this GUC
488 * corresponds to this exactly: enable_indexscan=off disables both
489 * index-scan and index-only scan paths, whereas enable_indexonlyscan=off
490 * converts the index-only scan paths that we would have considered into
491 * index scan paths.
492 */
506 {
510 }
512 {
518 }
525
526 /* Allow plugins to take control after we've initialized "glob" */
528 (*planner_setup_hook) (glob, parse, query_string, cursorOptions,
529 &tuple_fraction, es);
530
531 /* primary planning entry point (may recurse for subqueries) */
533 tuple_fraction, NULL);
534
535 /* Select best Path and turn it into a Plan */
538
540
541 /*
542 * If creating a plan for a scrollable cursor, make sure it can run
543 * backwards on demand. Add a Material node at the top at need.
544 */
546 {
549 }
550
551 /*
552 * Optionally add a Gather node for testing purposes, provided this is
553 * actually a safe thing to do.
554 *
555 * We can add Gather even when top_plan has parallel-safe initPlans, but
556 * then we have to move the initPlans to the Gather node because of
557 * SS_finalize_plan's limitations. That would cause cosmetic breakage of
558 * regression tests when debug_parallel_query = regress, because initPlans
559 * that would normally appear on the top_plan move to the Gather, causing
560 * them to disappear from EXPLAIN output. That doesn't seem worth kluging
561 * EXPLAIN to hide, so skip it when debug_parallel_query = regress.
562 */
564 top_plan->parallel_safe &&
567 {
571
576 gather->num_workers = 1;
579
580 /* Transfer any initPlans to the new top node */
583
584 /*
585 * Since this Gather has no parallel-aware descendants to signal to,
586 * we don't need a rescan Param.
587 */
588 gather->rescan_param = -1;
589
590 /*
591 * Ideally we'd use cost_gather here, but setting up dummy path data
592 * to satisfy it doesn't seem much cleaner than knowing what it does.
593 */
595 parallel_setup_cost;
602
603 /*
604 * Delete the initplans' cost from top_plan. We needn't add it to the
605 * Gather node, since the above coding already included it there.
606 */
611
612 /* use parallel mode for parallel plans. */
614
616 }
617
618 /*
619 * If any Params were generated, run through the plan tree and compute
620 * each plan node's extParam/allParam sets. Ideally we'd merge this into
621 * set_plan_references' tree traversal, but for now it has to be separate
622 * because we need to visit subplans before not after main plan.
623 */
625 {
628 {
631
632 SS_finalize_plan(subroot, subplan);
633 }
635 }
636
637 /* final cleanup of the plan */
644 /* ... and the subplans (both regular subplans and initplans) */
647 {
650
652 }
653
654 /* build the PlannedStmt result */
656
663 result->transientPlan = glob->transientPlan;
664 result->dependsOnRole = glob->dependsOnRole;
665 result->parallelModeNeeded = glob->parallelModeNeeded;
667 result->partPruneInfos = glob->partPruneInfos;
668 result->rtable = glob->finalrtable;
670 glob->prunableRelids);
671 result->permInfos = glob->finalrteperminfos;
672 result->subrtinfos = glob->subrtinfos;
673 result->appendRelations = glob->appendRelations;
674 result->subplans = glob->subplans;
675 result->rewindPlanIDs = glob->rewindPlanIDs;
676 result->rowMarks = glob->finalrowmarks;
677
678 /*
679 * Compute resultRelationRelids and rowMarkRelids from resultRelations and
680 * rowMarks. These can be used for cheap membership checks.
681 */
688
689 result->relationOids = glob->relationOids;
690 result->invalItems = glob->invalItems;
691 result->paramExecTypes = glob->paramExecTypes;
692 /* utilityStmt should be null, but we might as well copy it */
694 result->elidedNodes = glob->elidedNodes;
697
701 {
703
704 /*
705 * Decide how much effort should be put into generating better code.
706 */
713
714 /*
715 * Decide which operations should be JITed.
716 */
721 }
722
723 /* Allow plugins to take control before we discard "glob" */
726
728 DestroyPartitionDirectory(glob->partition_directory);
729
731}
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:346
Plan * materialize_finished_plan(Plan *subplan)
Definition createplan.c:6509
void DestroyPartitionDirectory(PartitionDirectory pdir)
Definition partdesc.c:484
PlannerInfo * subquery_planner(PlannerGlobal *glob, Query *parse, char *plan_name, PlannerInfo *parent_root, PlannerInfo *alternative_root, bool hasRecursion, double tuple_fraction, SetOperationStmt *setops)
Definition planner.c:770
Path * get_cheapest_fractional_path(RelOptInfo *rel, double tuple_fraction)
Definition planner.c:6848
Plan * set_plan_references(PlannerInfo *root, Plan *plan)
Definition setrefs.c:291
Definition plannodes.h:1357
Definition plannodes.h:192
void SS_compute_initplan_cost(List *init_plans, Cost *initplan_cost_p, bool *unsafe_initplans_p)
Definition subselect.c:2495
References PlannerGlobal::allRelids, PlannerGlobal::appendRelations, Assert, bms_add_member(), bms_difference(), CMD_SELECT, create_plan(), CURSOR_OPT_FAST_PLAN, CURSOR_OPT_PARALLEL_OK, CURSOR_OPT_SCROLL, cursor_tuple_fraction, DEBUG_PARALLEL_OFF, debug_parallel_query, DEBUG_PARALLEL_REGRESS, PlannerGlobal::default_pgs_mask, PlannerGlobal::dependsOnRole, DestroyPartitionDirectory(), PlannerGlobal::elidedNodes, enable_bitmapscan, enable_gathermerge, enable_hashjoin, enable_indexonlyscan, enable_indexscan, enable_material, enable_memoize, enable_mergejoin, enable_nestloop, enable_partitionwise_join, enable_seqscan, enable_tidscan, ExecSupportsBackwardScan(), fb(), fetch_upper_rel(), PlannerGlobal::finalrowmarks, PlannerGlobal::finalrtable, PlannerGlobal::finalrteperminfos, forboth, get_cheapest_fractional_path(), PlannerGlobal::invalItems, IsParallelWorker, IsUnderPostmaster, jit_above_cost, jit_enabled, jit_expressions, jit_inline_above_cost, jit_optimize_above_cost, jit_tuple_deforming, PlannerGlobal::lastPHId, PlannerGlobal::lastPlanNodeId, PlannerGlobal::lastRowMarkId, lfirst, lfirst_int, lfirst_node, list_length(), makeNode, materialize_finished_plan(), max_parallel_hazard(), max_parallel_workers_per_gather, PlannerGlobal::maxParallelHazard, NIL, parallel_setup_cost, parallel_tuple_cost, PlannerGlobal::parallelModeNeeded, PlannerGlobal::parallelModeOK, PlannerGlobal::paramExecTypes, parse(), PlannerGlobal::partPruneInfos, PGJIT_DEFORM, PGJIT_EXPR, PGJIT_INLINE, PGJIT_NONE, PGJIT_OPT3, PGJIT_PERFORM, PGS_APPEND, PGS_BITMAPSCAN, PGS_CONSIDER_INDEXONLY, PGS_CONSIDER_NONPARTIAL, PGS_CONSIDER_PARTITIONWISE, PGS_FOREIGNJOIN, PGS_GATHER, PGS_GATHER_MERGE, PGS_HASHJOIN, PGS_INDEXONLYSCAN, PGS_INDEXSCAN, PGS_MERGE_APPEND, PGS_MERGEJOIN_MATERIALIZE, PGS_MERGEJOIN_PLAIN, PGS_NESTLOOP_MATERIALIZE, PGS_NESTLOOP_MEMOIZE, PGS_NESTLOOP_PLAIN, PGS_SEQSCAN, PGS_TIDSCAN, PLAN_STMT_STANDARD, planner_setup_hook, planner_shutdown_hook, PlannerGlobal::prunableRelids, PlannerGlobal::relationOids, result, PlannerGlobal::resultRelations, PlannerGlobal::rewindPlanIDs, root, set_plan_references(), SS_compute_initplan_cost(), SS_finalize_plan(), PlannerGlobal::subpaths, PlannerGlobal::subplans, subquery_planner(), PlannerGlobal::subrtinfos, PlannerGlobal::transientPlan, and UPPERREL_FINAL.
Referenced by delay_execution_planner(), pgss_planner(), and planner().
◆ standard_qp_callback()
|
static |
Definition at line 3723 of file planner.c.
3724{
3729
3730 /*
3731 * Calculate pathkeys that represent grouping/ordering and/or ordered
3732 * aggregate requirements.
3733 */
3735 {
3736 /*
3737 * With grouping sets, just use the first RollupData's groupClause. We
3738 * don't make any effort to optimize grouping clauses when there are
3739 * grouping sets, nor can we combine aggregate ordering keys with
3740 * grouping.
3741 */
3744
3746 {
3748
3749 /*
3750 * The groupClause is logically below the grouping step. So if
3751 * there is an RTE entry for the grouping step, we need to remove
3752 * its RT index from the sort expressions before we make PathKeys
3753 * for them.
3754 */
3755 root->group_pathkeys =
3757 &groupClause,
3758 tlist,
3759 false,
3760 parse->hasGroupRTE,
3761 &sortable,
3762 false);
3765 }
3766 else
3767 {
3769 root->num_groupby_pathkeys = 0;
3770 }
3771 }
3773 {
3774 /*
3775 * With a plain GROUP BY list, we can remove any grouping items that
3776 * are proven redundant by EquivalenceClass processing. For example,
3777 * we can remove y given "WHERE x = y GROUP BY x, y". These aren't
3778 * especially common cases, but they're nearly free to detect. Note
3779 * that we remove redundant items from processed_groupClause but not
3780 * the original parse->groupClause.
3781 */
3783
3784 /*
3785 * Convert group clauses into pathkeys. Set the ec_sortref field of
3786 * EquivalenceClass'es if it's not set yet.
3787 */
3788 root->group_pathkeys =
3790 &root->processed_groupClause,
3791 tlist,
3792 true,
3793 false,
3794 &sortable,
3795 true);
3797 {
3798 /* Can't sort; no point in considering aggregate ordering either */
3800 root->num_groupby_pathkeys = 0;
3801 }
3802 else
3803 {
3805 /* If we have ordered aggs, consider adding onto group_pathkeys */
3808 }
3809 }
3810 else
3811 {
3813 root->num_groupby_pathkeys = 0;
3814 }
3815
3816 /* We consider only the first (bottom) window in pathkeys logic */
3818 {
3820
3822 wc,
3823 tlist);
3824 }
3825 else
3827
3828 /*
3829 * As with GROUP BY, we can discard any DISTINCT items that are proven
3830 * redundant by EquivalenceClass processing. The non-redundant list is
3831 * kept in root->processed_distinctClause, leaving the original
3832 * parse->distinctClause alone.
3833 */
3835 {
3837
3838 /* Make a copy since pathkey processing can modify the list */
3840 root->distinct_pathkeys =
3842 &root->processed_distinctClause,
3843 tlist,
3844 true,
3845 false,
3846 &sortable,
3847 false);
3850 }
3851 else
3853
3854 root->sort_pathkeys =
3856 parse->sortClause,
3857 tlist);
3858
3859 /* setting setop_pathkeys might be useful to the union planner */
3861 {
3862 List *groupClauses;
3864
3866
3867 root->setop_pathkeys =
3869 &groupClauses,
3870 tlist,
3871 false,
3872 false,
3873 &sortable,
3874 false);
3877 }
3878 else
3880
3881 /*
3882 * Figure out whether we want a sorted result from query_planner.
3883 *
3884 * If we have a sortable GROUP BY clause, then we want a result sorted
3885 * properly for grouping. Otherwise, if we have window functions to
3886 * evaluate, we try to sort for the first window. Otherwise, if there's a
3887 * sortable DISTINCT clause that's more rigorous than the ORDER BY clause,
3888 * we try to produce output that's sufficiently well sorted for the
3889 * DISTINCT. Otherwise, if there is an ORDER BY clause, we want to sort
3890 * by the ORDER BY clause. Otherwise, if we're a subquery being planned
3891 * for a set operation which can benefit from presorted results and have a
3892 * sortable targetlist, we want to sort by the target list.
3893 *
3894 * Note: if we have both ORDER BY and GROUP BY, and ORDER BY is a superset
3895 * of GROUP BY, it would be tempting to request sort by ORDER BY --- but
3896 * that might just leave us failing to exploit an available sort order at
3897 * all. Needs more thought. The choice for DISTINCT versus ORDER BY is
3898 * much easier, since we know that the parser ensured that one is a
3899 * superset of the other.
3900 */
3912 else
3914}
static void adjust_group_pathkeys_for_groupagg(PlannerInfo *root)
Definition planner.c:3499
static List * generate_setop_child_grouplist(SetOperationStmt *op, List *targetlist)
Definition planner.c:8607
References adjust_group_pathkeys_for_groupagg(), Assert, fb(), generate_setop_child_grouplist(), grouping_is_sortable(), linitial_node, list_copy(), list_length(), make_pathkeys_for_sortclauses(), make_pathkeys_for_sortclauses_extended(), make_pathkeys_for_window(), NIL, parse(), and root.
Referenced by grouping_planner().
◆ subquery_planner()
| PlannerInfo * subquery_planner | ( | PlannerGlobal * | glob, |
| Query * | parse, | ||
| char * | plan_name, | ||
| PlannerInfo * | parent_root, | ||
| PlannerInfo * | alternative_root, | ||
| bool | hasRecursion, | ||
| double | tuple_fraction, | ||
| SetOperationStmt * | setops | ||
| ) |
Definition at line 770 of file planner.c.
774{
783 ListCell *l;
784
785 /* Create a PlannerInfo data structure for this subquery */
788 root->glob = glob;
790 root->plan_name = plan_name;
793 else
794 root->alternative_plan_name = plan_name;
805 root->last_rinfo_serial = 0;
806 root->all_result_relids =
820 root->qual_security_level = 0;
824 root->hasRecursion = hasRecursion;
826 if (hasRecursion)
828 else
829 root->wt_param_id = -1;
831
832 /*
833 * Create the top-level join domain. This won't have valid contents until
834 * deconstruct_jointree fills it in, but the node needs to exist before
835 * that so we can build EquivalenceClasses referencing it.
836 */
838
839 /*
840 * If there is a WITH list, process each WITH query and either convert it
841 * to RTE_SUBQUERY RTE(s) or build an initplan SubPlan structure for it.
842 */
845
846 /*
847 * If it's a MERGE command, transform the joinlist as appropriate.
848 */
849 transform_MERGE_to_join(parse);
850
851 /*
852 * Reject FOR PORTION OF on a generated column. We can't write to a
853 * virtual generated column, and a stored generated column should be
854 * written by its own expression.
855 *
856 * We do this in the planner rather than parse analysis so that updatable
857 * views have been rewritten; otherwise they would mask which columns are
858 * generated. We need to check before preprocess_relation_rtes(), so that
859 * for virtual generated columns we still have the rangeVar. After that
860 * it is replaced by the column's expression.
861 *
862 * XXX: We plan to implement PERIODs as stored generated columns, so later
863 * we will loosen this restriction if the column belongs to a PERIOD.
864 */
866 {
869
874 forPortionOf->range_name)));
875 }
876
877 /*
878 * Scan the rangetable for relation RTEs and retrieve the necessary
879 * catalog information for each relation. Using this information, clear
880 * the inh flag for any relation that has no children, collect not-null
881 * attribute numbers for any relation that has column not-null
882 * constraints, and expand virtual generated columns for any relation that
883 * contains them. Note that this step does not descend into sublinks and
884 * subqueries; if we pull up any sublinks or subqueries below, their
885 * relation RTEs are processed just before pulling them up.
886 */
888
889 /*
890 * If the FROM clause is empty, replace it with a dummy RTE_RESULT RTE, so
891 * that we don't need so many special cases to deal with that situation.
892 */
893 replace_empty_jointree(parse);
894
895 /*
896 * Look for ANY and EXISTS SubLinks in WHERE and JOIN/ON clauses, and try
897 * to transform them into joins. Note that this step does not descend
898 * into subqueries; if we pull up any subqueries below, their SubLinks are
899 * processed just before pulling them up.
900 */
903
904 /*
905 * Scan the rangetable for function RTEs, do const-simplification on them,
906 * and then inline them if possible (producing subqueries that might get
907 * pulled up next). Recursion issues here are handled in the same way as
908 * for SubLinks.
909 */
911
912 /*
913 * Check to see if any subqueries in the jointree can be merged into this
914 * query.
915 */
917
918 /*
919 * If this is a simple UNION ALL query, flatten it into an appendrel. We
920 * do this now because it requires applying pull_up_subqueries to the leaf
921 * queries of the UNION ALL, which weren't touched above because they
922 * weren't referenced by the jointree (they will be after we do this).
923 */
926
927 /*
928 * Survey the rangetable to see what kinds of entries are present. We can
929 * skip some later processing if relevant SQL features are not used; for
930 * example if there are no JOIN RTEs we can avoid the expense of doing
931 * flatten_join_alias_vars(). This must be done after we have finished
932 * adding rangetable entries, of course. (Note: actually, processing of
933 * inherited or partitioned rels can cause RTEs for their child tables to
934 * get added later; but those must all be RTE_RELATION entries, so they
935 * don't invalidate the conclusions drawn here.)
936 */
939 root->group_rtindex = 0;
943 {
945
947 {
952 break;
955 break;
959 break;
960 default:
961 /* No work here for other RTE types */
962 break;
963 }
964
967
968 /*
969 * We can also determine the maximum security level required for any
970 * securityQuals now. Addition of inheritance-child RTEs won't affect
971 * this, because child tables don't have their own securityQuals; see
972 * expand_single_inheritance_child().
973 */
977 }
978
979 /*
980 * If we have now verified that the query target relation is
981 * non-inheriting, mark it as a leaf target.
982 */
984 {
986
988 root->leaf_result_relids =
990 }
991
992 /*
993 * This would be a convenient time to check access permissions for all
994 * relations mentioned in the query, since it would be better to fail now,
995 * before doing any detailed planning. However, for historical reasons,
996 * we leave this to be done at executor startup.
997 *
998 * Note, however, that we do need to check access permissions for any view
999 * relations mentioned in the query, in order to prevent information being
1000 * leaked by selectivity estimation functions, which only check view owner
1001 * permissions on underlying tables (see all_rows_selectable() and its
1002 * callers). This is a little ugly, because it means that access
1003 * permissions for views will be checked twice, which is another reason
1004 * why it would be better to do all the ACL checks here.
1005 */
1007 {
1009
1012 {
1015
1021 }
1022 }
1023
1024 /*
1025 * Preprocess RowMark information. We need to do this after subquery
1026 * pullup, so that all base relations are present.
1027 */
1029
1030 /*
1031 * Set hasHavingQual to remember if HAVING clause is present. Needed
1032 * because preprocess_expression will reduce a constant-true condition to
1033 * an empty qual list ... but "HAVING TRUE" is not a semantic no-op.
1034 */
1036
1037 /*
1038 * Do expression preprocessing on targetlist and quals, as well as other
1039 * random expressions in the querytree. Note that we do not need to
1040 * handle sort/group expressions explicitly, because they are actually
1041 * part of the targetlist.
1042 */
1045 EXPRKIND_TARGET);
1046
1049 {
1051
1053 EXPRKIND_QUAL);
1056 }
1058
1061 EXPRKIND_TARGET);
1062
1064
1066 EXPRKIND_QUAL);
1067
1069 {
1071
1072 /* partitionClause/orderClause are sort/group expressions */
1074 EXPRKIND_LIMIT);
1076 EXPRKIND_LIMIT);
1077 }
1078
1080 EXPRKIND_LIMIT);
1082 EXPRKIND_LIMIT);
1083
1085 {
1089 EXPRKIND_ARBITER_ELEM);
1090 parse->onConflict->arbiterWhere =
1092 parse->onConflict->arbiterWhere,
1093 EXPRKIND_QUAL);
1097 EXPRKIND_TARGET);
1098 parse->onConflict->onConflictWhere =
1100 parse->onConflict->onConflictWhere,
1101 EXPRKIND_QUAL);
1102 /* exclRelTlist contains only Vars, so no preprocessing needed */
1103 }
1104
1106 {
1107 parse->forPortionOf->targetRange =
1109 parse->forPortionOf->targetRange,
1110 EXPRKIND_TARGET);
1115 }
1116
1118 {
1120
1124 EXPRKIND_TARGET);
1125 action->qual =
1128 EXPRKIND_QUAL);
1129 }
1130
1131 parse->mergeJoinCondition =
1133
1136 EXPRKIND_APPINFO);
1137
1138 /* Also need to preprocess expressions within RTEs */
1140 {
1142 int kind;
1144
1146 {
1151 EXPRKIND_TABLESAMPLE);
1152 }
1154 {
1155 /*
1156 * We don't want to do all preprocessing yet on the subquery's
1157 * expressions, since that will happen when we plan it. But if it
1158 * contains any join aliases of our level, those have to get
1159 * expanded now, because planning of the subquery won't do it.
1160 * That's only possible if the subquery is LATERAL.
1161 */
1166 }
1168 {
1169 /* Preprocess the function expression(s) fully */
1173 }
1175 {
1176 /* Preprocess the function expression(s) fully */
1180 }
1182 {
1183 /* Preprocess the values lists fully */
1187 }
1189 {
1190 /* Preprocess the groupexprs list fully */
1193 EXPRKIND_GROUPEXPR);
1194 }
1195
1196 /*
1197 * Process each element of the securityQuals list as if it were a
1198 * separate qual expression (as indeed it is). We need to do it this
1199 * way to get proper canonicalization of AND/OR structure. Note that
1200 * this converts each element into an implicit-AND sublist.
1201 */
1203 {
1206 EXPRKIND_QUAL);
1207 }
1208 }
1209
1210 /*
1211 * Now that we are done preprocessing expressions, and in particular done
1212 * flattening join alias variables, get rid of the joinaliasvars lists.
1213 * They no longer match what expressions in the rest of the tree look
1214 * like, because we have not preprocessed expressions in those lists (and
1215 * do not want to; for example, expanding a SubLink there would result in
1216 * a useless unreferenced subplan). Leaving them in place simply creates
1217 * a hazard for later scans of the tree. We could try to prevent that by
1218 * using QTW_IGNORE_JOINALIASES in every tree scan done after this point,
1219 * but that doesn't sound very reliable.
1220 */
1222 {
1224 {
1226
1228 }
1229 }
1230
1231 /*
1232 * Before we flatten GROUP Vars, identify HAVING clauses whose equality
1233 * semantics disagree with the GROUP BY's. See find_having_conflicts.
1234 */
1237 root->group_rtindex);
1238 else
1240
1241 /*
1242 * Replace any Vars in the subquery's targetlist and havingQual that
1243 * reference GROUP outputs with the underlying grouping expressions.
1244 *
1245 * Note that we need to perform this replacement after we've preprocessed
1246 * the grouping expressions. This is to ensure that there is only one
1247 * instance of SubPlan for each SubLink contained within the grouping
1248 * expressions.
1249 */
1251 {
1254 parse->havingQual =
1256 }
1257
1258 /* Constant-folding might have removed all set-returning functions */
1261
1262 /*
1263 * If we have grouping sets, expand the groupingSets tree of this query to
1264 * a flat list of grouping sets. We need to do this before optimizing
1265 * HAVING, since we can't easily tell if there's an empty grouping set
1266 * until we have this representation.
1267 */
1269 {
1270 parse->groupingSets =
1272 }
1273
1274 /*
1275 * In some cases we may want to transfer a HAVING clause into WHERE. We
1276 * cannot do so if the HAVING clause contains aggregates (obviously) or
1277 * volatile functions (since a HAVING clause is supposed to be executed
1278 * only once per group). We also can't do this if there are any grouping
1279 * sets and the clause references any columns that are nullable by the
1280 * grouping sets; the nulled values of those columns are not available
1281 * before the grouping step. (The test on groupClause might seem wrong,
1282 * but it's okay: it's just an optimization to avoid running pull_varnos
1283 * when there cannot be any Vars in the HAVING clause.)
1284 *
1285 * We also cannot do this for HAVING clauses that conflict with GROUP BY
1286 * on collation or operator family. Both kinds of conflict are detected
1287 * before flatten_group_exprs (see find_having_conflicts above) and
1288 * recorded in the havingPushdownConflicts bitmapset. The bitmapset
1289 * indexes remain valid here because flatten_group_exprs uses
1290 * expression_tree_mutator, which preserves the list length and ordering
1291 * of havingQual.
1292 *
1293 * Also, it may be that the clause is so expensive to execute that we're
1294 * better off doing it only once per group, despite the loss of
1295 * selectivity. This is hard to estimate short of doing the entire
1296 * planning process twice, so we use a heuristic: clauses containing
1297 * subplans are left in HAVING. Otherwise, we move or copy the HAVING
1298 * clause into WHERE, in hopes of eliminating tuples before aggregation
1299 * instead of after.
1300 *
1301 * If the query has no empty grouping set then we can simply move such a
1302 * clause into WHERE; any group that fails the clause will not be in the
1303 * output because none of its tuples will reach the grouping or
1304 * aggregation stage. Otherwise we have to keep the clause in HAVING to
1305 * ensure that we don't emit a bogus aggregated row. But then the HAVING
1306 * clause must be degenerate (variable-free), so we can copy it into WHERE
1307 * so that query_planner() can use it in a gating Result node. (This could
1308 * be done better, but it seems not worth optimizing.)
1309 *
1310 * Note that a HAVING clause may contain expressions that are not fully
1311 * preprocessed. This can happen if these expressions are part of
1312 * grouping items. In such cases, they are replaced with GROUP Vars in
1313 * the parser and then replaced back after we're done with expression
1314 * preprocessing on havingQual. This is not an issue if the clause
1315 * remains in HAVING, because these expressions will be matched to lower
1316 * target items in setrefs.c. However, if the clause is moved or copied
1317 * into WHERE, we need to ensure that these expressions are fully
1318 * preprocessed.
1319 *
1320 * Note that both havingQual and parse->jointree->quals are in
1321 * implicitly-ANDed-list form at this point, even though they are declared
1322 * as Node *.
1323 */
1325 havingIdx = 0;
1327 {
1329
1336 {
1337 /* keep it in HAVING */
1339 }
1343 {
1344 /* There is GROUP BY, but no empty grouping set */
1346
1347 /* Preprocess the HAVING clause fully */
1349 EXPRKIND_QUAL);
1350 /* ... and move it to WHERE */
1354 }
1355 else
1356 {
1357 /* There is an empty grouping set (perhaps implicitly) */
1359
1360 /* Preprocess the HAVING clause fully */
1362 EXPRKIND_QUAL);
1363 /* ... and put a copy in WHERE */
1367 /* ... and also keep it in HAVING */
1369 }
1370
1371 havingIdx++;
1372 }
1374
1375 /*
1376 * If we have any outer joins, try to reduce them to plain inner joins.
1377 * This step is most easily done after we've done expression
1378 * preprocessing.
1379 */
1382
1383 /*
1384 * If we have any RTE_RESULT relations, see if they can be deleted from
1385 * the jointree. We also rely on this processing to flatten single-child
1386 * FromExprs underneath outer joins. This step is most effectively done
1387 * after we've done expression preprocessing and outer join reduction.
1388 */
1391
1392 /*
1393 * Do the main planning.
1394 */
1396
1397 /*
1398 * Capture the set of outer-level param IDs we have access to, for use in
1399 * extParam/allParam calculations later.
1400 */
1402
1403 /*
1404 * If any initPlans were created in this query level, adjust the surviving
1405 * Paths' costs and parallel-safety flags to account for them. The
1406 * initPlans won't actually get attached to the plan tree till
1407 * create_plan() runs, but we must include their effects now.
1408 */
1411
1412 /*
1413 * Make sure we've identified the cheapest Path for the final rel. (By
1414 * doing this here not in grouping_planner, we include initPlan costs in
1415 * the decision, though it's unlikely that will change anything.)
1416 */
1418
1420}
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition aclchk.c:2672
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Definition parse_agg.c:2019
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
Definition parse_relation.c:4080
static int list_cell_number(const List *l, const ListCell *c)
Definition pg_list.h:365
static Bitmapset * find_having_conflicts(Query *parse, Index group_rtindex)
Definition planner.c:1587
static void grouping_planner(PlannerInfo *root, double tuple_fraction, SetOperationStmt *setops)
Definition planner.c:1704
void preprocess_function_rtes(PlannerInfo *root)
Definition prepjointree.c:1173
void flatten_simple_union_all(PlannerInfo *root)
Definition prepjointree.c:3134
void remove_useless_result_rtes(PlannerInfo *root)
Definition prepjointree.c:3887
Query * preprocess_relation_rtes(PlannerInfo *root)
Definition prepjointree.c:421
Definition primnodes.h:2431
Definition parsenodes.h:1406
Definition primnodes.h:112
Definition parsenodes.h:1462
Definition parsenodes.h:1487
void SS_charge_for_initplans(PlannerInfo *root, RelOptInfo *final_rel)
Definition subselect.c:2431
Node * flatten_group_exprs(PlannerInfo *root, Query *query, Node *node)
Definition var.c:999
References aclcheck_error(), ACLCHECK_NO_PRIV, Assert, assign_special_exec_param(), bms_is_member(), bms_make_singleton(), contain_agg_clause(), contain_subplans(), contain_volatile_functions(), copyObject, CurrentMemoryContext, WindowClause::endOffset, ereport, errcode(), errmsg, ERROR, ExecCheckOneRelPerms(), expand_grouping_sets(), expression_returns_set(), EXPRKIND_APPINFO, EXPRKIND_ARBITER_ELEM, EXPRKIND_GROUPEXPR, EXPRKIND_LIMIT, EXPRKIND_QUAL, EXPRKIND_RTFUNC, EXPRKIND_RTFUNC_LATERAL, EXPRKIND_TABLEFUNC, EXPRKIND_TABLEFUNC_LATERAL, EXPRKIND_TABLESAMPLE, EXPRKIND_TARGET, EXPRKIND_VALUES, EXPRKIND_VALUES_LATERAL, fb(), fetch_upper_rel(), find_having_conflicts(), flatten_group_exprs(), flatten_join_alias_vars(), flatten_simple_union_all(), get_attgenerated(), get_rel_name(), getRTEPermissionInfo(), grouping_planner(), IS_OUTER_JOIN, lappend(), lfirst, lfirst_node, linitial, list_cell_number(), list_concat(), list_length(), list_make1, makeNode, Max, NIL, OBJECT_VIEW, parse(), preprocess_expression(), preprocess_function_rtes(), preprocess_qual_conditions(), preprocess_relation_rtes(), preprocess_rowmarks(), pull_up_sublinks(), pull_up_subqueries(), pull_varnos(), ForPortionOfExpr::range_name, ForPortionOfExpr::rangeVar, reduce_outer_joins(), remove_useless_result_rtes(), replace_empty_jointree(), result, root, rt_fetch, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, set_cheapest(), SS_charge_for_initplans(), SS_identify_outer_params(), SS_process_ctes(), WindowClause::startOffset, transform_MERGE_to_join(), UPPERREL_FINAL, and Var::varattno.
Referenced by make_subplan(), recurse_set_operations(), set_subquery_pathlist(), SS_process_ctes(), and standard_planner().
Variable Documentation
◆ create_upper_paths_hook
| create_upper_paths_hook_type create_upper_paths_hook = NULL |
Definition at line 83 of file planner.c.
Referenced by create_distinct_paths(), create_ordered_paths(), create_ordinary_grouping_paths(), create_partial_distinct_paths(), create_window_paths(), grouping_planner(), and postprocess_setop_rel().
◆ cursor_tuple_fraction
| double cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION |
Definition at line 68 of file planner.c.
Referenced by standard_planner().
◆ debug_parallel_query
| int debug_parallel_query = DEBUG_PARALLEL_OFF |
Definition at line 69 of file planner.c.
Referenced by ProcessParallelMessage(), query_planner(), and standard_planner().
◆ enable_distinct_reordering
Definition at line 71 of file planner.c.
Referenced by get_useful_pathkeys_for_distinct().
◆ parallel_leader_participation
Definition at line 70 of file planner.c.
Referenced by ExecGather(), ExecGatherMerge(), ExecInitGather(), and get_parallel_divisor().
◆ planner_hook
| planner_hook_type planner_hook = NULL |
Definition at line 74 of file planner.c.
Referenced by _PG_init(), and planner().
◆ planner_setup_hook
| planner_setup_hook_type planner_setup_hook = NULL |
Definition at line 77 of file planner.c.
Referenced by pgpa_planner_install_hooks(), and standard_planner().
◆ planner_shutdown_hook
| planner_shutdown_hook_type planner_shutdown_hook = NULL |
Definition at line 80 of file planner.c.
Referenced by pgpa_planner_install_hooks(), and standard_planner().
