Optimizer cleanups.

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;

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;
 			}
 		}
 	}