Push qual clauses containing subplans to the back of the qual list

at each plan node.  Per gripe from Ross Reedstrom.

diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index cba1b2027d34b4c9351b875126cfc15adc8cbba6..717fcfa3cec75c300daa871d0059460fb60ff071 100644 (file)
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.121 2002/11/06 22:31:24 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.122 2002/11/15 02:36:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -70,6 +70,7 @@ static Node *fix_indxqual_operand(Node *node, int baserelid,
                     IndexOptInfo *index,
                     Oid *opclass);
 static List *switch_outer(List *clauses);
+static List *order_qual_clauses(Query *root, List *clauses);
 static void copy_path_costsize(Plan *dest, Path *src);
 static void copy_plan_costsize(Plan *dest, Plan *src);
 static SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid);
@@ -182,6 +183,9 @@ create_scan_plan(Query *root, Path *best_path)
     */
    scan_clauses = get_actual_clauses(best_path->parent->baserestrictinfo);
 
+   /* Sort clauses into best execution order */
+   scan_clauses = order_qual_clauses(root, scan_clauses);
+
    switch (best_path->pathtype)
    {
        case T_SeqScan:
@@ -359,6 +363,7 @@ create_result_plan(Query *root, ResultPath *best_path)
 {
    Result     *plan;
    List       *tlist;
+   List       *constclauses;
    Plan       *subplan;
 
    if (best_path->path.parent)
@@ -371,7 +376,9 @@ create_result_plan(Query *root, ResultPath *best_path)
    else
        subplan = NULL;
 
-   plan = make_result(tlist, (Node *) best_path->constantqual, subplan);
+   constclauses = order_qual_clauses(root, best_path->constantqual);
+
+   plan = make_result(tlist, (Node *) constclauses, subplan);
 
    return plan;
 }
@@ -1212,6 +1219,43 @@ switch_outer(List *clauses)
    return t_list;
 }
 
+/*
+ * order_qual_clauses
+ *     Given a list of qual clauses that will all be evaluated at the same
+ *     plan node, sort the list into the order we want to check the quals
+ *     in at runtime.
+ *
+ * Ideally the order should be driven by a combination of execution cost and
+ * selectivity, but unfortunately we have so little information about
+ * execution cost of operators that it's really hard to do anything smart.
+ * For now, we just move any quals that contain SubPlan references (but not
+ * InitPlan references) to the end of the list.
+ */
+static List *
+order_qual_clauses(Query *root, List *clauses)
+{
+   List       *nosubplans;
+   List       *withsubplans;
+   List       *l;
+
+   /* No need to work hard if the query is subselect-free */
+   if (!root->hasSubLinks)
+       return clauses;
+
+   nosubplans = withsubplans = NIL;
+   foreach(l, clauses)
+   {
+       Node   *clause = lfirst(l);
+
+       if (contain_subplans(clause))
+           withsubplans = lappend(withsubplans, clause);
+       else
+           nosubplans = lappend(nosubplans, clause);
+   }
+
+   return nconc(nosubplans, withsubplans);
+}
+
 /*
  * Copy cost and size info from a Path node to the Plan node created from it.
  * The executor won't use this info, but it's needed by EXPLAIN.