diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c index cc7384f..adf209f 100644 --- a/src/backend/optimizer/path/joinpath.c +++ b/src/backend/optimizer/path/joinpath.c @@ -79,26 +79,25 @@ void add_paths_to_joinrel(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, SpecialJoinInfo *sjinfo, List *restrictlist) { JoinPathExtraData extra; bool mergejoin_allowed = true; - ListCell *lc; extra.restrictlist = restrictlist; extra.mergeclause_list = NIL; extra.sjinfo = sjinfo; - extra.param_source_rels = NULL; + extra.param_source_rels = joinrel->param_source_rels; /* * Find potential mergejoin clauses. We can skip this if we are not * interested in doing a mergejoin. However, mergejoin may be our only * way of implementing a full outer join, so override enable_mergejoin if * it's a full join. */ if (enable_mergejoin || jointype == JOIN_FULL) extra.mergeclause_list = select_mergejoin_clauses(root, joinrel, @@ -111,68 +110,20 @@ add_paths_to_joinrel(PlannerInfo *root, /* * If it's SEMI or ANTI join, compute correction factors for cost * estimation. These will be the same for all paths. */ if (jointype == JOIN_SEMI || jointype == JOIN_ANTI) compute_semi_anti_join_factors(root, outerrel, innerrel, jointype, sjinfo, restrictlist, &extra.semifactors); /* - * Decide whether it's sensible to generate parameterized paths for this - * joinrel, and if so, which relations such paths should require. There - * is usually no need to create a parameterized result path unless there - * is a join order restriction that prevents joining one of our input rels - * directly to the parameter source rel instead of joining to the other - * input rel. (But see allow_star_schema_join().) This restriction - * reduces the number of parameterized paths we have to deal with at - * higher join levels, without compromising the quality of the resulting - * plan. We express the restriction as a Relids set that must overlap the - * parameterization of any proposed join path. - */ - foreach(lc, root->join_info_list) - { - SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) lfirst(lc); - - /* - * SJ is relevant to this join if we have some part of its RHS - * (possibly not all of it), and haven't yet joined to its LHS. (This - * test is pretty simplistic, but should be sufficient considering the - * join has already been proven legal.) If the SJ is relevant, it - * presents constraints for joining to anything not in its RHS. - */ - if (bms_overlap(joinrel->relids, sjinfo->min_righthand) && - !bms_overlap(joinrel->relids, sjinfo->min_lefthand)) - extra.param_source_rels = bms_join(extra.param_source_rels, - bms_difference(root->all_baserels, - sjinfo->min_righthand)); - - /* full joins constrain both sides symmetrically */ - if (sjinfo->jointype == JOIN_FULL && - bms_overlap(joinrel->relids, sjinfo->min_lefthand) && - !bms_overlap(joinrel->relids, sjinfo->min_righthand)) - extra.param_source_rels = bms_join(extra.param_source_rels, - bms_difference(root->all_baserels, - sjinfo->min_lefthand)); - } - - /* - * However, when a LATERAL subquery is involved, there will simply not be - * any paths for the joinrel that aren't parameterized by whatever the - * subquery is parameterized by, unless its parameterization is resolved - * within the joinrel. So we might as well allow additional dependencies - * on whatever residual lateral dependencies the joinrel will have. - */ - extra.param_source_rels = bms_add_members(extra.param_source_rels, - joinrel->lateral_relids); - - /* * 1. Consider mergejoin paths where both relations must be explicitly * sorted. Skip this if we can't mergejoin. */ if (mergejoin_allowed) sort_inner_and_outer(root, joinrel, outerrel, innerrel, jointype, &extra); /* * 2. Consider paths where the outer relation need not be explicitly * sorted. This includes both nestloops and mergejoins where the outer diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index deef560..6720dee 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -108,20 +108,21 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptKind reloptkind) rel->reltarget = create_empty_pathtarget(); rel->pathlist = NIL; rel->ppilist = NIL; rel->partial_pathlist = NIL; rel->cheapest_startup_path = NULL; rel->cheapest_total_path = NULL; rel->cheapest_unique_path = NULL; rel->cheapest_parameterized_paths = NIL; rel->direct_lateral_relids = NULL; rel->lateral_relids = NULL; + rel->param_source_rels = NULL; rel->relid = relid; rel->rtekind = rte->rtekind; /* min_attr, max_attr, attr_needed, attr_widths are set below */ rel->lateral_vars = NIL; rel->lateral_referencers = NULL; rel->indexlist = NIL; rel->pages = 0; rel->tuples = 0; rel->allvisfrac = 0; rel->subroot = NULL; @@ -332,20 +333,21 @@ find_join_rel(PlannerInfo *root, Relids relids) RelOptInfo * build_join_rel(PlannerInfo *root, Relids joinrelids, RelOptInfo *outer_rel, RelOptInfo *inner_rel, SpecialJoinInfo *sjinfo, List **restrictlist_ptr) { RelOptInfo *joinrel; List *restrictlist; + ListCell *lc; /* * See if we already have a joinrel for this set of base rels. */ joinrel = find_join_rel(root, joinrelids); if (joinrel) { /* * Yes, so we only need to figure the restrictlist for this particular @@ -377,20 +379,21 @@ build_join_rel(PlannerInfo *root, joinrel->cheapest_startup_path = NULL; joinrel->cheapest_total_path = NULL; joinrel->cheapest_unique_path = NULL; joinrel->cheapest_parameterized_paths = NIL; /* init direct_lateral_relids from children; we'll finish it up below */ joinrel->direct_lateral_relids = bms_union(outer_rel->direct_lateral_relids, inner_rel->direct_lateral_relids); joinrel->lateral_relids = min_join_parameterization(root, joinrel->relids, outer_rel, inner_rel); + joinrel->param_source_rels = NULL; joinrel->relid = 0; /* indicates not a baserel */ joinrel->rtekind = RTE_JOIN; joinrel->min_attr = 0; joinrel->max_attr = 0; joinrel->attr_needed = NULL; joinrel->attr_widths = NULL; joinrel->lateral_vars = NIL; joinrel->lateral_referencers = NULL; joinrel->indexlist = NIL; joinrel->pages = 0; @@ -469,20 +472,68 @@ build_join_rel(PlannerInfo *root, * now we can finish computing that. This is much like the computation of * the transitively-closed lateral_relids in min_join_parameterization, * except that here we *do* have to consider the added PHVs. */ joinrel->direct_lateral_relids = bms_del_members(joinrel->direct_lateral_relids, joinrel->relids); if (bms_is_empty(joinrel->direct_lateral_relids)) joinrel->direct_lateral_relids = NULL; /* + * Decide whether it's sensible to generate parameterized paths for this + * joinrel, and if so, which relations such paths should require. There + * is usually no need to create a parameterized result path unless there + * is a join order restriction that prevents joining one of our input rels + * directly to the parameter source rel instead of joining to the other + * input rel. (But see allow_star_schema_join().) This restriction + * reduces the number of parameterized paths we have to deal with at + * higher join levels, without compromising the quality of the resulting + * plan. We express the restriction as a Relids set that must overlap the + * parameterization of any proposed join path. + */ + foreach(lc, root->join_info_list) + { + SpecialJoinInfo *sjinfo = (SpecialJoinInfo *) lfirst(lc); + + /* + * SJ is relevant to this join if we have some part of its RHS + * (possibly not all of it), and haven't yet joined to its LHS. (This + * test is pretty simplistic, but should be sufficient considering the + * join has already been proven legal.) If the SJ is relevant, it + * presents constraints for joining to anything not in its RHS. + */ + if (bms_overlap(joinrel->relids, sjinfo->min_righthand) && + !bms_overlap(joinrel->relids, sjinfo->min_lefthand)) + joinrel->param_source_rels = bms_join(joinrel->param_source_rels, + bms_difference(root->all_baserels, + sjinfo->min_righthand)); + + /* full joins constrain both sides symmetrically */ + if (sjinfo->jointype == JOIN_FULL && + bms_overlap(joinrel->relids, sjinfo->min_lefthand) && + !bms_overlap(joinrel->relids, sjinfo->min_righthand)) + joinrel->param_source_rels = bms_join(joinrel->param_source_rels, + bms_difference(root->all_baserels, + sjinfo->min_lefthand)); + } + + /* + * However, when a LATERAL subquery is involved, there will simply not be + * any paths for the joinrel that aren't parameterized by whatever the + * subquery is parameterized by, unless its parameterization is resolved + * within the joinrel. So we might as well allow additional dependencies + * on whatever residual lateral dependencies the joinrel will have. + */ + joinrel->param_source_rels = bms_add_members(joinrel->param_source_rels, + joinrel->lateral_relids); + + /* * Construct restrict and join clause lists for the new joinrel. (The * caller might or might not need the restrictlist, but I need it anyway * for set_joinrel_size_estimates().) */ restrictlist = build_joinrel_restrictlist(root, joinrel, outer_rel, inner_rel); if (restrictlist_ptr) *restrictlist_ptr = restrictlist; build_joinrel_joinlist(joinrel, outer_rel, inner_rel); diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h index 3a1255a..ef48cc2 100644 --- a/src/include/nodes/relation.h +++ b/src/include/nodes/relation.h @@ -502,20 +502,23 @@ typedef struct RelOptInfo struct Path *cheapest_startup_path; struct Path *cheapest_total_path; struct Path *cheapest_unique_path; List *cheapest_parameterized_paths; /* parameterization information needed for both base rels and join rels */ /* (see also lateral_vars and lateral_referencers) */ Relids direct_lateral_relids; /* rels directly laterally referenced */ Relids lateral_relids; /* minimum parameterization of rel */ + /* allowed targets for parameterization of result paths for join rels */ + Relids param_source_rels; + /* information about a base rel (not set for join rels!) */ Index relid; Oid reltablespace; /* containing tablespace */ RTEKind rtekind; /* RELATION, SUBQUERY, or FUNCTION */ AttrNumber min_attr; /* smallest attrno of rel (often <0) */ AttrNumber max_attr; /* largest attrno of rel */ Relids *attr_needed; /* array indexed [min_attr .. max_attr] */ int32 *attr_widths; /* array indexed [min_attr .. max_attr] */ List *lateral_vars; /* LATERAL Vars and PHVs referenced by rel */ Relids lateral_referencers; /* rels that reference me laterally */