*** a/src/backend/optimizer/path/costsize.c --- b/src/backend/optimizer/path/costsize.c *************** *** 108,113 **** bool enable_hashagg = true; --- 108,114 ---- bool enable_nestloop = true; bool enable_mergejoin = true; bool enable_hashjoin = true; + bool enable_joinremoval = true; typedef struct { *** a/src/backend/optimizer/path/joinpath.c --- b/src/backend/optimizer/path/joinpath.c *************** *** 41,46 **** static List *select_mergejoin_clauses(PlannerInfo *root, --- 41,49 ---- RelOptInfo *innerrel, List *restrictlist, JoinType jointype); + static bool rel_attrs_needed_above_join(RelOptInfo *rel, RelOptInfo *joinrel); + static bool test_join_removal(RelOptInfo *joinrel, RelOptInfo *rel, + List *inner_pathkeys_for_merge, bool *removejoinOK); /* *************** *** 158,163 **** sort_inner_and_outer(PlannerInfo *root, --- 161,167 ---- SpecialJoinInfo *sjinfo) { bool useallclauses; + bool removejoinOK = false; Path *outer_path; Path *inner_path; List *all_pathkeys; *************** *** 169,176 **** sort_inner_and_outer(PlannerInfo *root, */ switch (jointype) { - case JOIN_INNER: case JOIN_LEFT: case JOIN_SEMI: case JOIN_ANTI: case JOIN_UNIQUE_OUTER: --- 173,181 ---- */ switch (jointype) { case JOIN_LEFT: + removejoinOK = enable_joinremoval; + case JOIN_INNER: case JOIN_SEMI: case JOIN_ANTI: case JOIN_UNIQUE_OUTER: *************** *** 276,281 **** sort_inner_and_outer(PlannerInfo *root, --- 281,295 ---- cur_mergeclauses, outerkeys); + /* Join removal. */ + if (removejoinOK + && test_join_removal(joinrel, innerrel, innerkeys, &removejoinOK)) + { + add_paths_from_list(joinrel, outerrel->pathlist); + /* No point in considering any more join paths. */ + return; + } + /* Build pathkeys representing output sort order */ merge_pathkeys = build_join_pathkeys(root, joinrel, jointype, outerkeys); *************** *** 1048,1050 **** select_mergejoin_clauses(PlannerInfo *root, --- 1062,1196 ---- return result_list; } + + /* + * test_join_removal + * Attempt to prove that joining against the inner relation can't change + * the number of output rows. + */ + static bool + test_join_removal(RelOptInfo *joinrel, RelOptInfo *innerrel, + List *inner_pathkeys_for_merge, bool *removejoinOK) + { + bool any_hope_left = false; + bool useful_index_found = false; + ListCell *l; + + /* + * We're basically looking for an index-scan path over a unique index on a + * suitable set of columns. In the future, we might want to consider the + * case of a LEFT JOIN against a grouped subselect where the grouped + * columns are mergejoinable: + * SELECT c.* FROM customer c + * LEFT JOIN (SELECT customer_id, SUM(1) FROM customer_order + * GROUP BY 1) co ON c.id = co.customer_id + */ + foreach(l, innerrel->pathlist) + { + Path *path = lfirst(l); + /* + * Since we're only handling LEFT joins for now, we don't need to + * worry about whether the inner side of the join reduces the number + * of output rows. In general, that can only happen if there is a + * qual on the inner rel - but the rel_attrs_needed_above_join test + * will catch that case. + * + * We do need to worry about the join increasing the number of output + * rows. It suffices to find a unique index on all of the pathkeys for + * ANY possible way of doing the merge join. In other words, the + * presence of non-merge-joinable join clauses isn't a problem - and + * we don't need to use all of the clauses, either. In such cases, + * the unique index we're looking for will be stronger than necessary, + * but that doesn't matter (since this is an outer join). + * + * This algorithm can miss a legal join removal if the set of pathkeys + * that corresponds to the ordering of the relevant index is never + * tried, but it doesn't seem worth spending too much time worrying + * about that case for the same reasons mentioned in + * sort_outer_and_inner. + */ + if (IsA(path, IndexPath)) { + IndexOptInfo *info = ((IndexPath *) path)->indexinfo; + if (!info->unique) + continue; + /* + * What's going on here is a little bit subtle. The only possible + * source of pathkeys for the index path is the columns of the + * index, so we know that the pathkeys are derived from the index + * columns. However, we don't know that they're all present in + * the index-path's list of pathkeys, because the planner is free + * to truncate the pathkey list if the lower-order terms aren't + * useful to the current query. So we must check that the lists + * are of equal length. (If they aren't, the unique index isn't + * "unique enough", because it has lower-order terms.) + */ + if (info->ncolumns == list_length(path->pathkeys) + && compare_pathkeys(inner_pathkeys_for_merge, path->pathkeys) + == PATHKEYS_EQUAL) + { + useful_index_found = true; + break; + } + /* + * Since we found a unique index, there's still hope, even if this + * set of pathkeys doesn't pan out. + */ + any_hope_left = true; + } + /* + * In the future, we might want to consider other ways to prove that + * the left join can't increase the row count, such as a LEFT JOIN + * against a merge-joinable grouped subselect, like this: + * SELECT + * c.* + * FROM + * customer c + * LEFT JOIN (SELECT customer_id, SUM(1) FROM customer_order + * GROUP BY 1) co + * ON c.id = co.customer_id + */ + } + + /* + * We found a useful unique index. But we still can't remove the join + * unless the rel supplies no attrs. + */ + if (useful_index_found) + { + if (rel_attrs_needed_above_join(innerrel, joinrel)) + { + /* + * If the innerrel is supplying attributes, join removal fails, + * and there's no point in rescanning with a different set of + * pathkeys, so kill off any further attempts. + */ + *removejoinOK = false; + return false; + } + return true; + } + + /* No luck. */ + if (!any_hope_left) + *removejoinOK = false; + return false; + } + + /* + * rel_attrs_needed_above_join + * Determine whether any attributes from rel are used outside of joinrel. + * + * As a micro-optimization, it seems better to start with max_attr and count + * down rather than starting with min_attr and counting up, on the theory that + * the system attributes are somewhat less likely to be what is wanted and + * should be tested last. + */ + static bool + rel_attrs_needed_above_join(RelOptInfo *rel, RelOptInfo *joinrel) + { + int attroff; + for (attroff = rel->max_attr - rel->min_attr; attroff >= 0; --attroff) + if (!bms_is_subset(rel->attr_needed[attroff], joinrel->relids)) + return true; + return false; + } *** a/src/backend/optimizer/util/pathnode.c --- b/src/backend/optimizer/util/pathnode.c *************** *** 340,346 **** add_path(RelOptInfo *parent_rel, Path *new_path) /* * Delete the data pointed-to by the deleted cell, if possible */ ! if (!IsA(old_path, IndexPath)) pfree(old_path); /* Advance list pointer */ if (p1_prev) --- 340,346 ---- /* * Delete the data pointed-to by the deleted cell, if possible */ ! if (!IsA(old_path, IndexPath) && old_path->parent == parent_rel) pfree(old_path); /* Advance list pointer */ if (p1_prev) *************** *** 378,388 **** add_path(RelOptInfo *parent_rel, Path *new_path) else { /* Reject and recycle the new path */ ! if (!IsA(new_path, IndexPath)) pfree(new_path); } } /***************************************************************************** * PATH NODE CREATION ROUTINES --- 378,400 ---- else { /* Reject and recycle the new path */ ! if (!IsA(new_path, IndexPath) && new_path->parent == parent_rel) pfree(new_path); } } + /* + * add_paths_from_list + * Add each path from the list to parent_rel. + */ + void + add_paths_from_list(RelOptInfo *parent_rel, List *pathlist) + { + ListCell *lc; + + foreach (lc, pathlist) + add_path(parent_rel, (Path *) lfirst(lc)); + } /***************************************************************************** * PATH NODE CREATION ROUTINES *** a/src/backend/utils/misc/guc.c --- b/src/backend/utils/misc/guc.c *************** *** 648,653 **** static struct config_bool ConfigureNamesBool[] = --- 648,661 ---- true, NULL, NULL }, { + {"enable_joinremoval", PGC_USERSET, QUERY_TUNING_METHOD, + gettext_noop("Enables the planner's use of join removal."), + NULL + }, + &enable_joinremoval, + true, NULL, NULL + }, + { {"enable_hashjoin", PGC_USERSET, QUERY_TUNING_METHOD, gettext_noop("Enables the planner's use of hash join plans."), NULL *** a/src/backend/utils/misc/postgresql.conf.sample --- b/src/backend/utils/misc/postgresql.conf.sample *************** *** 190,195 **** --- 190,196 ---- #enable_seqscan = on #enable_sort = on #enable_tidscan = on + #enable_joinremoval = on # - Planner Cost Constants - *** a/src/include/optimizer/cost.h --- b/src/include/optimizer/cost.h *************** *** 59,64 **** extern bool enable_hashagg; --- 59,65 ---- extern bool enable_nestloop; extern bool enable_mergejoin; extern bool enable_hashjoin; + extern bool enable_joinremoval; extern int constraint_exclusion; extern double clamp_row_est(double nrows); *** a/src/include/optimizer/pathnode.h --- b/src/include/optimizer/pathnode.h *************** *** 26,31 **** extern int compare_fractional_path_costs(Path *path1, Path *path2, --- 26,32 ---- double fraction); extern void set_cheapest(RelOptInfo *parent_rel); extern void add_path(RelOptInfo *parent_rel, Path *new_path); + extern void add_paths_from_list(RelOptInfo *parent_rel, List *pathlist); extern Path *create_seqscan_path(PlannerInfo *root, RelOptInfo *rel); extern IndexPath *create_index_path(PlannerInfo *root, *** a/src/test/regress/expected/rangefuncs.out --- b/src/test/regress/expected/rangefuncs.out *************** *** 1,16 **** SELECT name, setting FROM pg_settings WHERE name LIKE 'enable%'; ! name | setting ! -------------------+--------- ! enable_bitmapscan | on ! enable_hashagg | on ! enable_hashjoin | on ! enable_indexscan | on ! enable_mergejoin | on ! enable_nestloop | on ! enable_seqscan | on ! enable_sort | on ! enable_tidscan | on ! (9 rows) CREATE TABLE foo2(fooid int, f2 int); INSERT INTO foo2 VALUES(1, 11); --- 1,17 ---- SELECT name, setting FROM pg_settings WHERE name LIKE 'enable%'; ! name | setting ! --------------------+--------- ! enable_bitmapscan | on ! enable_hashagg | on ! enable_hashjoin | on ! enable_indexscan | on ! enable_joinremoval | on ! enable_mergejoin | on ! enable_nestloop | on ! enable_seqscan | on ! enable_sort | on ! enable_tidscan | on ! (10 rows) CREATE TABLE foo2(fooid int, f2 int); INSERT INTO foo2 VALUES(1, 11);