Extend set-operation planning to keep track of the sort ordering induced

by the set operation, so that redundant sorts at higher levels can be
avoided.  This was foreseen a good while back, but not done.  Per request
from Karel Zak.

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index fea7e4fef131fa20873bd6a2c20078cddadb0099..c3cfe4be719719ba4ccd3dc2efdd0c639fd4e0c3 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.167 2004/02/13 22:26:30 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/plan/planner.c,v 1.168 2004/04/07 18:17:24 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -572,11 +572,23 @@ grouping_planner(Query *parse, double tuple_fraction)
 
        if (parse->setOperations)
        {
+               List   *set_sortclauses;
+
                /*
                 * Construct the plan for set operations.  The result will not
                 * need any work except perhaps a top-level sort and/or LIMIT.
                 */
-               result_plan = plan_set_operations(parse);
+               result_plan = plan_set_operations(parse,
+                                                                                 &set_sortclauses);
+
+               /*
+                * Calculate pathkeys representing the sort order (if any) of the
+                * set operation's result.  We have to do this before overwriting
+                * the sort key information...
+                */
+               current_pathkeys = make_pathkeys_for_sortclauses(set_sortclauses,
+                                                                                                       result_plan->targetlist);
+               current_pathkeys = canonicalize_pathkeys(parse, current_pathkeys);
 
                /*
                 * We should not need to call preprocess_targetlist, since we must
@@ -599,16 +611,7 @@ grouping_planner(Query *parse, double tuple_fraction)
                                         errmsg("SELECT FOR UPDATE is not allowed with UNION/INTERSECT/EXCEPT")));
 
                /*
-                * We set current_pathkeys NIL indicating we do not know sort
-                * order.  This is correct when the top set operation is UNION
-                * ALL, since the appended-together results are unsorted even if
-                * the subplans were sorted.  For other set operations we could be
-                * smarter --- room for future improvement!
-                */
-               current_pathkeys = NIL;
-
-               /*
-                * Calculate pathkeys that represent ordering requirements
+                * Calculate pathkeys that represent result ordering requirements
                 */
                sort_pathkeys = make_pathkeys_for_sortclauses(parse->sortClause,
                                                                                                          tlist);

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index 9424fc7148282623881835c51069522df418113f..b703bf2b86e095c81dcc95435f32e7f16334ca3e 100644 (file)
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -14,7 +14,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.108 2004/01/18 00:50:02 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/prep/prepunion.c,v 1.109 2004/04/07 18:17:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -45,11 +45,12 @@ typedef struct
 
 static Plan *recurse_set_operations(Node *setOp, Query *parse,
                                           List *colTypes, bool junkOK,
-                                          int flag, List *refnames_tlist);
+                                          int flag, List *refnames_tlist,
+                                          List **sortClauses);
 static Plan *generate_union_plan(SetOperationStmt *op, Query *parse,
-                                       List *refnames_tlist);
+                                       List *refnames_tlist, List **sortClauses);
 static Plan *generate_nonunion_plan(SetOperationStmt *op, Query *parse,
-                                          List *refnames_tlist);
+                                          List *refnames_tlist, List **sortClauses);
 static List *recurse_union_children(Node *setOp, Query *parse,
                                           SetOperationStmt *top_union,
                                           List *refnames_tlist);
@@ -75,9 +76,12 @@ static List *adjust_inherited_tlist(List *tlist, Oid old_relid, Oid new_relid);
  * This routine only deals with the setOperations tree of the given query.
  * Any top-level ORDER BY requested in parse->sortClause will be added
  * when we return to grouping_planner.
+ *
+ * *sortClauses is an output argument: it is set to a list of SortClauses
+ * representing the result ordering of the topmost set operation.
  */
 Plan *
-plan_set_operations(Query *parse)
+plan_set_operations(Query *parse, List **sortClauses)
 {
        SetOperationStmt *topop = (SetOperationStmt *) parse->setOperations;
        Node       *node;
@@ -113,7 +117,8 @@ plan_set_operations(Query *parse)
         */
        return recurse_set_operations((Node *) topop, parse,
                                                                  topop->colTypes, true, -1,
-                                                                 leftmostQuery->targetList);
+                                                                 leftmostQuery->targetList,
+                                                                 sortClauses);
 }
 
 /*
@@ -124,11 +129,13 @@ plan_set_operations(Query *parse)
  * junkOK: if true, child resjunk columns may be left in the result
  * flag: if >= 0, add a resjunk output column indicating value of flag
  * refnames_tlist: targetlist to take column names from
+ * *sortClauses: receives list of SortClauses for result plan, if any
  */
 static Plan *
 recurse_set_operations(Node *setOp, Query *parse,
                                           List *colTypes, bool junkOK,
-                                          int flag, List *refnames_tlist)
+                                          int flag, List *refnames_tlist,
+                                          List **sortClauses)
 {
        if (IsA(setOp, RangeTblRef))
        {
@@ -155,6 +162,13 @@ recurse_set_operations(Node *setOp, Query *parse,
                                                          NIL,
                                                          rtr->rtindex,
                                                          subplan);
+
+               /*
+                * We don't bother to determine the subquery's output ordering
+                * since it won't be reflected in the set-op result anyhow.
+                */
+               *sortClauses = NIL;
+
                return plan;
        }
        else if (IsA(setOp, SetOperationStmt))
@@ -164,9 +178,11 @@ recurse_set_operations(Node *setOp, Query *parse,
 
                /* UNIONs are much different from INTERSECT/EXCEPT */
                if (op->op == SETOP_UNION)
-                       plan = generate_union_plan(op, parse, refnames_tlist);
+                       plan = generate_union_plan(op, parse, refnames_tlist,
+                                                                          sortClauses);
                else
-                       plan = generate_nonunion_plan(op, parse, refnames_tlist);
+                       plan = generate_nonunion_plan(op, parse, refnames_tlist,
+                                                                                 sortClauses);
 
                /*
                 * If necessary, add a Result node to project the caller-requested
@@ -206,7 +222,8 @@ recurse_set_operations(Node *setOp, Query *parse,
  */
 static Plan *
 generate_union_plan(SetOperationStmt *op, Query *parse,
-                                       List *refnames_tlist)
+                                       List *refnames_tlist,
+                                       List **sortClauses)
 {
        List       *planlist;
        List       *tlist;
@@ -249,7 +266,11 @@ generate_union_plan(SetOperationStmt *op, Query *parse,
                sortList = addAllTargetsToSortList(NULL, NIL, tlist, false);
                plan = (Plan *) make_sort_from_sortclauses(parse, sortList, plan);
                plan = (Plan *) make_unique(plan, sortList);
+               *sortClauses = sortList;
        }
+       else
+               *sortClauses = NIL;
+
        return plan;
 }
 
@@ -258,23 +279,27 @@ generate_union_plan(SetOperationStmt *op, Query *parse,
  */
 static Plan *
 generate_nonunion_plan(SetOperationStmt *op, Query *parse,
-                                          List *refnames_tlist)
+                                          List *refnames_tlist,
+                                          List **sortClauses)
 {
        Plan       *lplan,
                           *rplan,
                           *plan;
        List       *tlist,
                           *sortList,
-                          *planlist;
+                          *planlist,
+                          *child_sortclauses;
        SetOpCmd        cmd;
 
        /* Recurse on children, ensuring their outputs are marked */
        lplan = recurse_set_operations(op->larg, parse,
                                                                   op->colTypes, false, 0,
-                                                                  refnames_tlist);
+                                                                  refnames_tlist,
+                                                                  &child_sortclauses);
        rplan = recurse_set_operations(op->rarg, parse,
                                                                   op->colTypes, false, 1,
-                                                                  refnames_tlist);
+                                                                  refnames_tlist,
+                                                                  &child_sortclauses);
        planlist = makeList2(lplan, rplan);
 
        /*
@@ -315,6 +340,9 @@ generate_nonunion_plan(SetOperationStmt *op, Query *parse,
                        break;
        }
        plan = (Plan *) make_setop(cmd, plan, sortList, length(op->colTypes) + 1);
+
+       *sortClauses = sortList;
+
        return plan;
 }
 
@@ -329,6 +357,8 @@ recurse_union_children(Node *setOp, Query *parse,
                                           SetOperationStmt *top_union,
                                           List *refnames_tlist)
 {
+       List   *child_sortclauses;
+
        if (IsA(setOp, SetOperationStmt))
        {
                SetOperationStmt *op = (SetOperationStmt *) setOp;
@@ -359,7 +389,8 @@ recurse_union_children(Node *setOp, Query *parse,
         */
        return makeList1(recurse_set_operations(setOp, parse,
                                                                                        top_union->colTypes, false,
-                                                                                       -1, refnames_tlist));
+                                                                                       -1, refnames_tlist,
+                                                                                       &child_sortclauses));
 }
 
 /*

diff --git a/src/include/optimizer/prep.h b/src/include/optimizer/prep.h
index 6255c3623075ecc26bcc4dab124de774bdbdeb25..7f38bb795a7aea9cec4535c743ac7773d9fb6c8b 100644 (file)
--- a/src/include/optimizer/prep.h
+++ b/src/include/optimizer/prep.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/optimizer/prep.h,v 1.43 2003/12/28 21:57:37 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/optimizer/prep.h,v 1.44 2004/04/07 18:17:25 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -48,7 +48,7 @@ extern List *preprocess_targetlist(List *tlist, int command_type,
 /*
  * prototypes for prepunion.c
  */
-extern Plan *plan_set_operations(Query *parse);
+extern Plan *plan_set_operations(Query *parse, List **sortClauses);
 
 extern List *find_all_inheritors(Oid parentrel);