Optimizer cleanups.

diff --git a/src/backend/optimizer/util/ordering.c b/src/backend/optimizer/util/ordering.c
index 412879e8c7e2205891dc85a52f9e36c399d3e512..268f16df0e2d34afd4c1daa13880438981c44e3d 100644 (file)
--- a/src/backend/optimizer/util/ordering.c
+++ b/src/backend/optimizer/util/ordering.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.13 1999/02/11 17:00:48 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.14 1999/02/11 21:05:28 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -18,7 +18,8 @@
 #include "optimizer/internal.h"
 #include "optimizer/ordering.h"
 
-static bool equal_sortops_order(Oid *ordering1, Oid *ordering2, int *better_sort);
+static bool sortops_order_match(Oid *ordering1, Oid *ordering2,
+                                                               int *better_sort);
 
 /*
  * equal-path-ordering--
@@ -56,7 +57,7 @@ pathorder_match(PathOrder *path_ordering1,
        else if (path_ordering1->ordtype == SORTOP_ORDER &&
                         path_ordering2->ordtype == SORTOP_ORDER)
        {
-               return equal_sortops_order(path_ordering1->ord.sortop,
+               return sortops_order_match(path_ordering1->ord.sortop,
                                                                        path_ordering2->ord.sortop,
                                                                        better_sort);
        }
@@ -127,7 +128,7 @@ equal_merge_ordering(MergeOrder *merge_ordering1,
  *       Returns true iff the sort operators are in the same order.
  */
 static bool
-equal_sortops_order(Oid *ordering1, Oid *ordering2, int *better_sort)
+sortops_order_match(Oid *ordering1, Oid *ordering2, int *better_sort)
 {
        int                     i = 0;
 
@@ -160,7 +161,7 @@ equal_sortops_order(Oid *ordering1, Oid *ordering2, int *better_sort)
                *better_sort = 1;
                return true;
        }
-       
+
        if (ordering1[i] == 0 && ordering2[i] != 0)
        {
                *better_sort = 2;

diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 2a45890d3dcbcaef95eff929b056d19f08cdd49d..23e3e8ee0c21c04fec8ba880c09f87f3a02b8162 100644 (file)
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.30 1999/02/11 17:21:51 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/pathnode.c,v 1.31 1999/02/11 21:05:28 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -29,7 +29,7 @@
 
 #include "parser/parsetree.h"  /* for getrelid() */
 
-static Path *better_path(Path *new_path, List *unique_paths, bool *isNew);
+static Path *better_path(Path *new_path, List *unique_paths, bool *is_new);
 
 
 /*****************************************************************************
@@ -173,11 +173,14 @@ better_path(Path *new_path, List *unique_paths, bool *is_new)
                        printf("newpath\n");
                        pprint(new_path->pathkeys);
                        if (path->pathkeys && new_path->pathkeys &&
-                               length(lfirst(path->pathkeys)) >= 2 &&
-                               length(lfirst(path->pathkeys)) < length(lfirst(new_path->pathkeys)))
+                               length(lfirst(path->pathkeys)) >= 2/* &&
+                               length(lfirst(path->pathkeys)) <
+                               length(lfirst(new_path->pathkeys))*/)
                                sleep(0); /* set breakpoint here */
                }
-               if (!pathorder_match(new_path->pathorder, path->pathorder, &better_sort))
+               if (!pathorder_match(new_path->pathorder, path->pathorder,
+                       &better_sort) ||
+                       better_sort != 0)
                {
                        printf("oldord\n");
                        pprint(path->pathorder);
@@ -186,43 +189,43 @@ better_path(Path *new_path, List *unique_paths, bool *is_new)
                }
 #endif
 
-               if (pathkeys_match(new_path->pathkeys, path->pathkeys, &better_key))
+               if (pathkeys_match(new_path->pathkeys, path->pathkeys,
+                       &better_key) &&
+                       pathorder_match(new_path->pathorder, path->pathorder,
+                       &better_sort))
                {
-                       if (pathorder_match(new_path->pathorder, path->pathorder, &better_sort))
+                       /*
+                        * Replace pathkeys that match exactly, (1,2), (1,2).
+                        * Replace pathkeys (1,2) with (1,2,3) if the latter is not
+                        * more expensive and replace unordered path with ordered
+                        * path if it is not more expensive.  Favor sorted keys
+                        * over unsorted keys in the same way.
+                        */
+                                                       /* same keys, and new is cheaper, use it */
+                   if ((better_key == 0 && better_sort == 0 &&
+                                new_path->path_cost < path->path_cost) ||
+
+                                                       /* new is better, and cheaper, use it */
+                               (((better_key == 1 && better_sort != 2) ||
+                                 (better_key != 2 && better_sort == 1)) &&
+                                 new_path->path_cost <= path->path_cost))
                        {
-                               /*
-                                * Replace pathkeys that match exactly, (1,2), (1,2).
-                                * Replace pathkeys (1,2) with (1,2,3) if the latter is not
-                                * more expensive and replace unordered path with ordered
-                                * path if it is not more expensive.  Favor sorted keys
-                                * over unsorted keys in the same way.
-                                */
-                                                               /* same keys, and new is cheaper, use it */
-                           if ((better_key == 0 && better_sort == 0 &&
-                                        new_path->path_cost <  path->path_cost) ||
-
-                                                               /* new is better, and cheaper, use it */
-                                       (((better_key == 1 && better_sort != 2) ||
-                                         (better_key != 2 && better_sort == 1)) &&
-                                         new_path->path_cost <= path->path_cost))
-                               {
-                                       *is_new = false;
-                                       return new_path;
-                               }
-
-                                                               /* same keys, new is more expensive, stop */
-                           else if
-                                       ((better_key == 0 && better_sort == 0 &&
-                                         new_path->path_cost >= path->path_cost) ||
-
-                                                               /* old is better, and less expensive, stop */
-                                       (((better_key == 2 && better_sort != 1) ||
-                                         (better_key != 1 && better_sort == 2)) &&
-                                         new_path->path_cost >= path->path_cost))
-                               {
-                                       *is_new = false;
-                                       return NULL;
-                               }
+                               *is_new = false;
+                               return new_path;
+                       }
+
+                                                       /* same keys, new is more expensive, stop */
+                   else if
+                               ((better_key == 0 && better_sort == 0 &&
+                                 new_path->path_cost >= path->path_cost) ||
+
+                                                       /* old is better, and less expensive, stop */
+                               (((better_key == 2 && better_sort != 1) ||
+                                 (better_key != 1 && better_sort == 2)) &&
+                                 new_path->path_cost >= path->path_cost))
+                       {
+                               *is_new = false;
+                               return NULL;
                        }
                }
        }