*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.75 1999/08/22 20:14:47 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.76 1999/08/22 23:56:44 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Form_pg_index index);
static Node *fix_indxqual_operand(Node *node, IndexPath *index_path,
Form_pg_index index);
-static Noname *make_noname(List *tlist, List *pathkeys, Plan *plan_node);
static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
List *indxid, List *indxqual, List *indxqualorig);
static NestLoop *make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
* 'tlist' is the target list of the scan to be sorted or materialized
* 'pathkeys' is the list of pathkeys by which the result is to be sorted
* (NIL implies no sort needed, just materialize it)
- * 'plan_node' is the node which yields input tuples
+ * 'subplan' is the node which yields input tuples
*/
-static Noname *
+Noname *
make_noname(List *tlist,
List *pathkeys,
- Plan *plan_node)
+ Plan *subplan)
{
List *noname_tlist;
int numsortkeys;
/* need to sort */
retval = (Plan *) make_sort(noname_tlist,
_NONAME_RELATION_ID_,
- plan_node,
+ subplan,
numsortkeys);
}
else
/* no sort */
retval = (Plan *) make_material(noname_tlist,
_NONAME_RELATION_ID_,
- plan_node,
+ subplan,
0);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.42 1999/08/22 20:14:48 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.43 1999/08/22 23:56:45 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* qual is the qualification of the query
*
* Note: the Query node now also includes a query_pathkeys field, which
+ * is both an input and an output of query_planner(). The input value
* signals query_planner that the indicated sort order is wanted in the
- * final output plan. If, for some reason, query_planner is unable to
- * comply, it sets query_pathkeys to NIL before returning. (The reason
- * query_pathkeys is a Query field and not a passed parameter is that
- * the low-level routines in indxpath.c need to see it.)
+ * final output plan. The output value is the actual pathkeys of the
+ * selected path. This might not be the same as what the caller requested;
+ * the caller must do pathkeys_contained_in() to decide whether an
+ * explicit sort is still needed. (The main reason query_pathkeys is a
+ * Query field and not a passed parameter is that the low-level routines
+ * in indxpath.c need to see it.)
*
* Returns a query plan.
*/
if (root->query_pathkeys == NIL ||
pathkeys_contained_in(root->query_pathkeys,
final_rel->cheapestpath->pathkeys))
+ {
+ root->query_pathkeys = final_rel->cheapestpath->pathkeys;
return create_plan(final_rel->cheapestpath);
+ }
+
/*
* Otherwise, look to see if we have an already-ordered path that is
* cheaper than doing an explicit sort on cheapestpath.
if (sortedpath->path_cost <= cheapest_cost)
{
/* Found a better presorted path, use it */
+ root->query_pathkeys = sortedpath->pathkeys;
return create_plan(sortedpath);
}
/* otherwise, doing it the hard way is still cheaper */
* then poke the result.
*/
Plan *sortedplan = create_plan(sortedpath);
+ List *sortedpathkeys;
Assert(IsA(sortedplan, IndexScan));
((IndexScan *) sortedplan)->indxorderdir = BackwardScanDirection;
+ /*
+ * Need to generate commuted keys representing the actual
+ * sort order. This should succeed, probably, but just in
+ * case it does not, use the original root->query_pathkeys
+ * as a conservative approximation.
+ */
+ sortedpathkeys = copyObject(sortedpath->pathkeys);
+ if (commute_pathkeys(sortedpathkeys))
+ root->query_pathkeys = sortedpathkeys;
+
return sortedplan;
}
}
}
- /* Nothing for it but to sort the cheapestpath...
- *
- * We indicate we failed to sort the plan, and let the caller
- * stick the appropriate sort node on top. union_planner has to be
- * able to add a sort node anyway, so no need for extra code here.
+ /* Nothing for it but to sort the cheapestpath --- but we let the
+ * caller do that. union_planner has to be able to add a sort node
+ * anyway, so no need for extra code here. (Furthermore, the given
+ * pathkeys might involve something we can't compute yet, such as
+ * an aggregate function...)
*/
- root->query_pathkeys = NIL; /* sorry, it ain't sorted */
-
+ root->query_pathkeys = final_rel->cheapestpath->pathkeys;
return create_plan(final_rel->cheapestpath);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.64 1999/08/22 20:14:48 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.65 1999/08/22 23:56:45 tgl Exp $
*
*-------------------------------------------------------------------------
*/
AttrNumber **groupColIdx);
static Plan *make_groupplan(List *group_tlist, bool tuplePerGroup,
List *groupClause, AttrNumber *grpColIdx,
- bool is_sorted, Plan *subplan);
+ bool is_presorted, Plan *subplan);
static Plan *make_sortplan(List *tlist, List *sortcls, Plan *plannode);
/*****************************************************************************
List *rangetable = parse->rtable;
Plan *result_plan = (Plan *) NULL;
AttrNumber *groupColIdx = NULL;
- bool is_sorted = false;
+ List *current_pathkeys = NIL;
Index rt_index;
if (parse->unionClause)
parse->commandType,
parse->resultRelation,
parse->rtable);
+ /*
+ * We leave current_pathkeys NIL indicating we do not know sort order.
+ * Actually, for a normal UNION we have done an explicit sort; ought
+ * to change interface to plan_union_queries to pass that info back!
+ */
}
else if ((rt_index = first_inherit_rt_entry(rangetable)) != -1)
{
if (parse->rowMark != NULL)
elog(ERROR, "SELECT FOR UPDATE is not supported for inherit queries");
+ /*
+ * We leave current_pathkeys NIL indicating we do not know sort order
+ * of the Append-ed results.
+ */
}
else
{
}
}
+ /*
+ * Generate appropriate target list for subplan; may be different
+ * from tlist if grouping or aggregation is needed.
+ */
+ sub_tlist = make_subplanTargetList(parse, tlist, &groupColIdx);
+
/*
* Figure out whether we need a sorted result from query_planner.
*
* If we have a GROUP BY clause, then we want a result sorted
- * properly for grouping. Otherwise, if there is an ORDER BY clause
- * and no need for an aggregate node, we want to sort by the ORDER BY
- * clause. (XXX In some cases, we could presort even when there is
- * an aggregate, but I'll leave that refinement for another day.)
- *
- * NOTE: the reason we put the target pathkeys into the Query node
- * rather than passing them as an argument to query_planner is that
- * the low-level routines in indxpath.c want to be able to see them.
+ * properly for grouping. Otherwise, if there is an ORDER BY clause,
+ * we want to sort by the ORDER BY clause.
*/
if (parse->groupClause)
{
parse->query_pathkeys =
make_pathkeys_for_sortclauses(parse->groupClause, tlist);
}
- else if (parse->sortClause && ! parse->hasAggs)
+ else if (parse->sortClause)
{
parse->query_pathkeys =
make_pathkeys_for_sortclauses(parse->sortClause, tlist);
parse->query_pathkeys = NIL;
}
- /*
- * Generate appropriate target list for subplan; may be different
- * from tlist if grouping or aggregation is needed.
- */
- sub_tlist = make_subplanTargetList(parse, tlist, &groupColIdx);
-
/* Generate the (sub) plan */
result_plan = query_planner(parse,
parse->commandType,
sub_tlist,
(List *) parse->qual);
- /* query_planner sets query_pathkeys to NIL if it didn't make
- * a properly sorted plan
+ /* query_planner returns actual sort order (which is not
+ * necessarily what we requested) in query_pathkeys.
*/
- if (parse->query_pathkeys)
- is_sorted = true;
+ current_pathkeys = parse->query_pathkeys;
}
/* query_planner returns NULL if it thinks plan is bogus */
{
bool tuplePerGroup;
List *group_tlist;
+ List *group_pathkeys;
+ bool is_sorted;
/*
* Decide whether how many tuples per group the Group node needs
else
group_tlist = tlist;
+ /*
+ * Figure out whether the path result is already ordered the way we
+ * need it --- if so, no need for an explicit sort step.
+ */
+ group_pathkeys = make_pathkeys_for_sortclauses(parse->groupClause,
+ tlist);
+ if (pathkeys_contained_in(group_pathkeys, current_pathkeys))
+ {
+ is_sorted = true; /* no sort needed now */
+ /* current_pathkeys remains unchanged */
+ }
+ else
+ {
+ /* We will need to do an explicit sort by the GROUP BY clause.
+ * make_groupplan will do the work, but set current_pathkeys
+ * to indicate the resulting order.
+ */
+ is_sorted = false;
+ current_pathkeys = group_pathkeys;
+ }
+
result_plan = make_groupplan(group_tlist,
tuplePerGroup,
parse->groupClause,
groupColIdx,
is_sorted,
result_plan);
-
- /*
- * Assume the result of the group step is not ordered suitably
- * for any ORDER BY that may exist. XXX it might be; improve this!
- */
- is_sorted = false;
}
/*
/* HAVING clause, if any, becomes qual of the Agg node */
result_plan->qual = (List *) parse->havingQual;
- /*
- * Assume result is not ordered suitably for ORDER BY.
- * XXX it might be; improve this!
- */
- is_sorted = false;
+ /* Note: Agg does not affect any existing sort order of the tuples */
}
/*
* If we were not able to make the plan come out in the right order,
* add an explicit sort step.
*/
- if (parse->sortClause && ! is_sorted)
+ if (parse->sortClause)
{
- result_plan = make_sortplan(tlist, parse->sortClause, result_plan);
+ List *sort_pathkeys;
+
+ sort_pathkeys = make_pathkeys_for_sortclauses(parse->sortClause,
+ tlist);
+ if (! pathkeys_contained_in(sort_pathkeys, current_pathkeys))
+ {
+ result_plan = make_sortplan(tlist, parse->sortClause, result_plan);
+ }
}
/*
bool tuplePerGroup,
List *groupClause,
AttrNumber *grpColIdx,
- bool is_sorted,
+ bool is_presorted,
Plan *subplan)
{
int numCols = length(groupClause);
- if (! is_sorted)
+ if (! is_presorted)
{
/*
* The Sort node always just takes a copy of the subplan's tlist
projects / postgresql.git / commitdiff