Fix thinko: cost_mergejoin must pay attention to which side of the

mergeclause is which when extracting selectivity info.

diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index a94d54342e4374ec5fbff0bb50716f374339d555..e215a6cd3669e6e400aa23eef3049ab170931562 100644 (file)
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -42,7 +42,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.81 2002/03/01 06:01:19 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.82 2002/03/01 20:50:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -467,10 +467,11 @@ cost_sort(Path *path, Query *root,
        }
 
        /*
-        * Note: should we bother to assign a nonzero run_cost to reflect the
-        * overhead of extracting tuples from the sort result?  Probably not
-        * worth worrying about.
+        * Also charge a small amount (arbitrarily set equal to operator cost)
+        * per extracted tuple.
         */
+       run_cost += cpu_operator_cost * tuples;
+
        path->startup_cost = startup_cost;
        path->total_cost = startup_cost + run_cost;
 }
@@ -567,11 +568,12 @@ cost_mergejoin(Path *path, Query *root,
        Cost            run_cost = 0;
        Cost            cpu_per_tuple;
        RestrictInfo *firstclause;
+       Var                *leftvar;
        double          outer_rows,
                                inner_rows;
        double          ntuples;
-       Selectivity     leftscan,
-                               rightscan;
+       Selectivity     outerscansel,
+                               innerscansel;
        Path            sort_path;              /* dummy for result of cost_sort */
 
        if (!enable_mergejoin)
@@ -592,11 +594,24 @@ cost_mergejoin(Path *path, Query *root,
                mergejoinscansel(root, (Node *) firstclause->clause,
                                                 &firstclause->left_mergescansel,
                                                 &firstclause->right_mergescansel);
-       leftscan = firstclause->left_mergescansel;
-       rightscan = firstclause->right_mergescansel;
 
-       outer_rows = outer_path->parent->rows * leftscan;
-       inner_rows = inner_path->parent->rows * rightscan;
+       leftvar = get_leftop(firstclause->clause);
+       Assert(IsA(leftvar, Var));
+       if (intMember(leftvar->varno, outer_path->parent->relids))
+       {
+               /* left side of clause is outer */
+               outerscansel = firstclause->left_mergescansel;
+               innerscansel = firstclause->right_mergescansel;
+       }
+       else
+       {
+               /* left side of clause is inner */
+               outerscansel = firstclause->right_mergescansel;
+               innerscansel = firstclause->left_mergescansel;
+       }
+
+       outer_rows = outer_path->parent->rows * outerscansel;
+       inner_rows = inner_path->parent->rows * innerscansel;
 
        /* cost of source data */
 
@@ -616,13 +631,13 @@ cost_mergejoin(Path *path, Query *root,
                                  outer_path->parent->width);
                startup_cost += sort_path.startup_cost;
                run_cost += (sort_path.total_cost - sort_path.startup_cost)
-                       * leftscan;
+                       * outerscansel;
        }
        else
        {
                startup_cost += outer_path->startup_cost;
                run_cost += (outer_path->total_cost - outer_path->startup_cost)
-                       * leftscan;
+                       * outerscansel;
        }
 
        if (innersortkeys)                      /* do we need to sort inner? */
@@ -635,13 +650,13 @@ cost_mergejoin(Path *path, Query *root,
                                  inner_path->parent->width);
                startup_cost += sort_path.startup_cost;
                run_cost += (sort_path.total_cost - sort_path.startup_cost)
-                       * rightscan;
+                       * innerscansel;
        }
        else
        {
                startup_cost += inner_path->startup_cost;
                run_cost += (inner_path->total_cost - inner_path->startup_cost)
-                       * rightscan;
+                       * innerscansel;
        }
 
        /*