* for the mergejoin, we can skip doing an explicit sort.
*/
if (merge_path->outersortkeys &&
- pathkeys_contained_in(merge_path->outersortkeys,
- joinpath->outerjoinpath->pathkeys))
+ pathkeys_count_contained_in(merge_path->outersortkeys,
+ joinpath->outerjoinpath->pathkeys,
+ &merge_path->outer_presorted_keys))
merge_path->outersortkeys = NIL;
}
}
* 'inner_path' is the inner input to the join
* 'outersortkeys' is the list of sort keys for the outer path
* 'innersortkeys' is the list of sort keys for the inner path
+ * 'outer_presorted_keys' is the number of presorted keys of the outer path
* 'extra' contains miscellaneous information about the join
*
* Note: outersortkeys and innersortkeys should be NIL if no explicit
List *mergeclauses,
Path *outer_path, Path *inner_path,
List *outersortkeys, List *innersortkeys,
+ int outer_presorted_keys,
JoinPathExtraData *extra)
{
int disabled_nodes;
if (outersortkeys) /* do we need to sort outer? */
{
- bool use_incremental_sort = false;
- int presorted_keys;
+ /*
+ * We can assert that the outer path is not already ordered
+ * appropriately for the mergejoin; otherwise, outersortkeys would
+ * have been set to NIL.
+ */
+ Assert(!pathkeys_contained_in(outersortkeys, outer_path->pathkeys));
/*
* We choose to use incremental sort if it is enabled and there are
* presorted keys; otherwise we use full sort.
*/
- if (enable_incremental_sort)
+ if (enable_incremental_sort && outer_presorted_keys > 0)
{
- bool is_sorted PG_USED_FOR_ASSERTS_ONLY;
-
- is_sorted = pathkeys_count_contained_in(outersortkeys,
- outer_path->pathkeys,
- &presorted_keys);
- Assert(!is_sorted);
-
- if (presorted_keys > 0)
- use_incremental_sort = true;
+ cost_incremental_sort(&sort_path,
+ root,
+ outersortkeys,
+ outer_presorted_keys,
+ outer_path->disabled_nodes,
+ outer_path->startup_cost,
+ outer_path->total_cost,
+ outer_path_rows,
+ outer_path->pathtarget->width,
+ 0.0,
+ work_mem,
+ -1.0);
}
-
- if (!use_incremental_sort)
+ else
{
cost_sort(&sort_path,
root,
work_mem,
-1.0);
}
- else
- {
- cost_incremental_sort(&sort_path,
- root,
- outersortkeys,
- presorted_keys,
- outer_path->disabled_nodes,
- outer_path->startup_cost,
- outer_path->total_cost,
- outer_path_rows,
- outer_path->pathtarget->width,
- 0.0,
- work_mem,
- -1.0);
- }
+
disabled_nodes += sort_path.disabled_nodes;
startup_cost += sort_path.startup_cost;
startup_cost += (sort_path.total_cost - sort_path.startup_cost)
if (innersortkeys) /* do we need to sort inner? */
{
+ /*
+ * We can assert that the inner path is not already ordered
+ * appropriately for the mergejoin; otherwise, innersortkeys would
+ * have been set to NIL.
+ */
+ Assert(!pathkeys_contained_in(innersortkeys, inner_path->pathkeys));
+
/*
* We do not consider incremental sort for inner path, because
* incremental sort does not support mark/restore.
bool is_partial)
{
Relids required_outer;
+ int outer_presorted_keys = 0;
JoinCostWorkspace workspace;
if (is_partial)
/*
* If the given paths are already well enough ordered, we can skip doing
* an explicit sort.
+ *
+ * We need to determine the number of presorted keys of the outer path to
+ * decide whether explicit incremental sort can be applied when
+ * outersortkeys is not NIL. We do not need to do the same for the inner
+ * path though, as incremental sort currently does not support
+ * mark/restore.
*/
if (outersortkeys &&
- pathkeys_contained_in(outersortkeys, outer_path->pathkeys))
+ pathkeys_count_contained_in(outersortkeys, outer_path->pathkeys,
+ &outer_presorted_keys))
outersortkeys = NIL;
if (innersortkeys &&
pathkeys_contained_in(innersortkeys, inner_path->pathkeys))
initial_cost_mergejoin(root, &workspace, jointype, mergeclauses,
outer_path, inner_path,
outersortkeys, innersortkeys,
+ outer_presorted_keys,
extra);
if (add_path_precheck(joinrel, workspace.disabled_nodes,
required_outer,
mergeclauses,
outersortkeys,
- innersortkeys));
+ innersortkeys,
+ outer_presorted_keys));
}
else
{
JoinType jointype,
JoinPathExtraData *extra)
{
+ int outer_presorted_keys = 0;
JoinCostWorkspace workspace;
/*
/*
* If the given paths are already well enough ordered, we can skip doing
* an explicit sort.
+ *
+ * We need to determine the number of presorted keys of the outer path to
+ * decide whether explicit incremental sort can be applied when
+ * outersortkeys is not NIL. We do not need to do the same for the inner
+ * path though, as incremental sort currently does not support
+ * mark/restore.
*/
if (outersortkeys &&
- pathkeys_contained_in(outersortkeys, outer_path->pathkeys))
+ pathkeys_count_contained_in(outersortkeys, outer_path->pathkeys,
+ &outer_presorted_keys))
outersortkeys = NIL;
if (innersortkeys &&
pathkeys_contained_in(innersortkeys, inner_path->pathkeys))
initial_cost_mergejoin(root, &workspace, jointype, mergeclauses,
outer_path, inner_path,
outersortkeys, innersortkeys,
+ outer_presorted_keys,
extra);
if (!add_partial_path_precheck(joinrel, workspace.disabled_nodes,
NULL,
mergeclauses,
outersortkeys,
- innersortkeys));
+ innersortkeys,
+ outer_presorted_keys));
}
/*
{
Relids outer_relids = outer_path->parent->relids;
Plan *sort_plan;
- bool use_incremental_sort = false;
- int presorted_keys;
+
+ /*
+ * We can assert that the outer path is not already ordered
+ * appropriately for the mergejoin; otherwise, outersortkeys would
+ * have been set to NIL.
+ */
+ Assert(!pathkeys_contained_in(best_path->outersortkeys,
+ outer_path->pathkeys));
/*
* We choose to use incremental sort if it is enabled and there are
* presorted keys; otherwise we use full sort.
*/
- if (enable_incremental_sort)
- {
- bool is_sorted PG_USED_FOR_ASSERTS_ONLY;
-
- is_sorted = pathkeys_count_contained_in(best_path->outersortkeys,
- outer_path->pathkeys,
- &presorted_keys);
- Assert(!is_sorted);
-
- if (presorted_keys > 0)
- use_incremental_sort = true;
- }
-
- if (!use_incremental_sort)
- {
- sort_plan = (Plan *)
- make_sort_from_pathkeys(outer_plan,
- best_path->outersortkeys,
- outer_relids);
-
- label_sort_with_costsize(root, (Sort *) sort_plan, -1.0);
- }
- else
+ if (enable_incremental_sort && best_path->outer_presorted_keys > 0)
{
sort_plan = (Plan *)
make_incrementalsort_from_pathkeys(outer_plan,
best_path->outersortkeys,
outer_relids,
- presorted_keys);
+ best_path->outer_presorted_keys);
label_incrementalsort_with_costsize(root,
(IncrementalSort *) sort_plan,
best_path->outersortkeys,
-1.0);
}
+ else
+ {
+ sort_plan = (Plan *)
+ make_sort_from_pathkeys(outer_plan,
+ best_path->outersortkeys,
+ outer_relids);
+
+ label_sort_with_costsize(root, (Sort *) sort_plan, -1.0);
+ }
outer_plan = sort_plan;
outerpathkeys = best_path->outersortkeys;
*/
Relids inner_relids = inner_path->parent->relids;
- Sort *sort = make_sort_from_pathkeys(inner_plan,
- best_path->innersortkeys,
- inner_relids);
+ Sort *sort;
+
+ /*
+ * We can assert that the inner path is not already ordered
+ * appropriately for the mergejoin; otherwise, innersortkeys would
+ * have been set to NIL.
+ */
+ Assert(!pathkeys_contained_in(best_path->innersortkeys,
+ inner_path->pathkeys));
+
+ sort = make_sort_from_pathkeys(inner_plan,
+ best_path->innersortkeys,
+ inner_relids);
label_sort_with_costsize(root, sort, -1.0);
inner_plan = (Plan *) sort;
* (this should be a subset of the restrict_clauses list)
* 'outersortkeys' are the sort varkeys for the outer relation
* 'innersortkeys' are the sort varkeys for the inner relation
+ * 'outer_presorted_keys' is the number of presorted keys of the outer path
*/
MergePath *
create_mergejoin_path(PlannerInfo *root,
Relids required_outer,
List *mergeclauses,
List *outersortkeys,
- List *innersortkeys)
+ List *innersortkeys,
+ int outer_presorted_keys)
{
MergePath *pathnode = makeNode(MergePath);
pathnode->path_mergeclauses = mergeclauses;
pathnode->outersortkeys = outersortkeys;
pathnode->innersortkeys = innersortkeys;
+ pathnode->outer_presorted_keys = outer_presorted_keys;
/* pathnode->skip_mark_restore will be set by final_cost_mergejoin */
/* pathnode->materialize_inner will be set by final_cost_mergejoin */
* mergejoin. If it is not NIL then it is a PathKeys list describing
* the ordering that must be created by an explicit Sort node.
*
+ * outer_presorted_keys is the number of presorted keys of the outer
+ * path that match outersortkeys. It is used to determine whether
+ * explicit incremental sort can be applied when outersortkeys is not
+ * NIL. We do not track the number of presorted keys of the inner
+ * path, as incremental sort currently does not support mark/restore.
+ *
* skip_mark_restore is true if the executor need not do mark/restore calls.
* Mark/restore overhead is usually required, but can be skipped if we know
* that the executor need find only one match per outer tuple, and that the
List *path_mergeclauses; /* join clauses to be used for merge */
List *outersortkeys; /* keys for explicit sort, if any */
List *innersortkeys; /* keys for explicit sort, if any */
+ int outer_presorted_keys; /* number of presorted keys of the
+ * outer path */
bool skip_mark_restore; /* can executor skip mark/restore? */
bool materialize_inner; /* add Materialize to inner? */
} MergePath;
List *mergeclauses,
Path *outer_path, Path *inner_path,
List *outersortkeys, List *innersortkeys,
+ int outer_presorted_keys,
JoinPathExtraData *extra);
extern void final_cost_mergejoin(PlannerInfo *root, MergePath *path,
JoinCostWorkspace *workspace,
Relids required_outer,
List *mergeclauses,
List *outersortkeys,
- List *innersortkeys);
+ List *innersortkeys,
+ int outer_presorted_keys);
extern HashPath *create_hashjoin_path(PlannerInfo *root,
RelOptInfo *joinrel,
projects / thirdparty / postgresql.git / commitdiff
