Extend code that deduces implied equality clauses to detect whether a

clause being added to a particular restriction-clause list is redundant
with those already in the list.  This avoids useless work at runtime,
and (perhaps more importantly) keeps the selectivity estimation routines
from generating too-small estimates of numbers of output rows.
Also some minor improvements in OPTIMIZER_DEBUG displays.

Author: tglsfdc

src/backend/nodes/print.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.47 2001/03/22 03:59:32 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.48 2001/10/18 16:11:41 tgl Exp $
  *
  * HISTORY
  *	  AUTHOR			DATE			MAJOR EVENT
@@ -20,10 +20,12 @@
 #include "postgres.h"
 
 #include "access/printtup.h"
+#include "catalog/pg_type.h"
 #include "nodes/print.h"
 #include "optimizer/clauses.h"
 #include "parser/parsetree.h"
 #include "utils/lsyscache.h"
+#include "utils/syscache.h"
 
 static char *plannode_type(Plan *p);
 
@@ -188,6 +190,36 @@ print_expr(Node *expr, List *rtable)
 		}
 		printf("%s.%s", relname, attname);
 	}
+	else if (IsA(expr, Const))
+	{
+		Const	   *c = (Const *) expr;
+		HeapTuple	typeTup;
+		Oid			typoutput;
+		Oid			typelem;
+		char	   *outputstr;
+
+		if (c->constisnull)
+		{
+			printf("NULL");
+			return;
+		}
+
+		typeTup = SearchSysCache(TYPEOID,
+								 ObjectIdGetDatum(c->consttype),
+								 0, 0, 0);
+		if (!HeapTupleIsValid(typeTup))
+			elog(ERROR, "Cache lookup for type %u failed", c->consttype);
+		typoutput = ((Form_pg_type) GETSTRUCT(typeTup))->typoutput;
+		typelem = ((Form_pg_type) GETSTRUCT(typeTup))->typelem;
+		ReleaseSysCache(typeTup);
+
+		outputstr = DatumGetCString(OidFunctionCall3(typoutput,
+													 c->constvalue,
+													 ObjectIdGetDatum(typelem),
+													 Int32GetDatum(-1)));
+		printf("%s", outputstr);
+		pfree(outputstr);
+	}
 	else if (IsA(expr, Expr))
 	{
 		Expr	   *e = (Expr *) expr;
@@ -232,7 +264,7 @@ print_pathkeys(List *pathkeys, List *rtable)
 			if (lnext(k))
 				printf(", ");
 		}
-		printf(") ");
+		printf(")");
 		if (lnext(i))
 			printf(", ");
 	}

src/backend/optimizer/README

@@ -461,6 +461,23 @@ code than it would otherwise have, and reduces the number of tuples
 processed in join stages, so it's a win to make these deductions even
 if we weren't forced to.
 
+When we generate implied equality constraints, we may find ourselves
+adding redundant clauses to specific relations.  For example, consider
+	SELECT * FROM t1, t2, t3 WHERE t1.a = t2.b AND t2.b = t3.c;
+We will generate the implied clause t1.a = t3.c and add it to the tree.
+This is good since it allows us to consider joining t1 and t3 directly,
+which we otherwise wouldn't do.  But when we reach the stage of joining
+all three relations, we will have redundant join clauses --- eg, if we
+join t1 and t2 first, then the path that joins (t1 t2) to t3 will have
+both t2.b = t3.c and t1.a = t3.c as restriction clauses.  This is bad;
+not only is evaluation of the extra clause useless work at runtime,
+but the selectivity estimator routines will underestimate the number
+of tuples produced since they won't know that the two clauses are
+perfectly redundant.  We fix this by detecting and removing redundant
+clauses as the restriction clause list is built for each join.  (We
+can't do it sooner, since which clauses are redundant will vary depending
+on the join order.)
+
 Yet another implication of all this is that mergejoinable operators
 must form closed equivalence sets.  For example, if "int2 = int4"
 and "int4 = int8" are both marked mergejoinable, then there had better

src/backend/optimizer/path/allpaths.c

@@ -8,13 +8,16 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.78 2001/07/31 17:56:30 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/allpaths.c,v 1.79 2001/10/18 16:11:41 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #include "postgres.h"
 
+#ifdef OPTIMIZER_DEBUG
+#include "nodes/print.h"
+#endif
 #include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/geqo.h"
@@ -42,11 +45,6 @@ static void set_subquery_pathlist(Query *root, RelOptInfo *rel,
 static RelOptInfo *make_one_rel_by_joins(Query *root, int levels_needed,
 					  List *initial_rels);
 
-#ifdef OPTIMIZER_DEBUG
-static void debug_print_rel(Query *root, RelOptInfo *rel);
-
-#endif
-
 
 /*
  * make_one_rel
@@ -116,6 +114,10 @@ set_base_rel_pathlists(Query *root)
 			/* Plain relation */
 			set_plain_rel_pathlist(root, rel, rte);
 		}
+
+#ifdef OPTIMIZER_DEBUG
+		debug_print_rel(root, rel);
+#endif
 	}
 }
 
@@ -520,32 +522,40 @@ make_one_rel_by_joins(Query *root, int levels_needed, List *initial_rels)
 #ifdef OPTIMIZER_DEBUG
 
 static void
-print_joinclauses(Query *root, List *clauses)
+print_relids(Relids relids)
+{
+	List	   *l;
+
+	foreach(l, relids)
+	{
+		printf("%d", lfirsti(l));
+		if (lnext(l))
+			printf(" ");
+	}
+}
+
+static void
+print_restrictclauses(Query *root, List *clauses)
 {
 	List	   *l;
-	extern void print_expr(Node *expr, List *rtable);	/* in print.c */
 
 	foreach(l, clauses)
 	{
 		RestrictInfo *c = lfirst(l);
 
 		print_expr((Node *) c->clause, root->rtable);
 		if (lnext(l))
-			printf(" ");
+			printf(", ");
 	}
 }
 
 static void
 print_path(Query *root, Path *path, int indent)
 {
-	char	   *ptype = NULL;
-	JoinPath   *jp;
-	bool		join = false;
+	const char   *ptype;
+	bool		join;
 	int			i;
 
-	for (i = 0; i < indent; i++)
-		printf("\t");
-
 	switch (nodeTag(path))
 	{
 		case T_Path:
@@ -556,6 +566,10 @@ print_path(Query *root, Path *path, int indent)
 			ptype = "IdxScan";
 			join = false;
 			break;
+		case T_TidPath:
+			ptype = "TidScan";
+			join = false;
+			break;
 		case T_NestPath:
 			ptype = "Nestloop";
 			join = true;
@@ -569,89 +583,91 @@ print_path(Query *root, Path *path, int indent)
 			join = true;
 			break;
 		default:
+			ptype = "???Path";
+			join = false;
 			break;
 	}
+
+	for (i = 0; i < indent; i++)
+		printf("\t");
+	printf("%s(", ptype);
+	print_relids(path->parent->relids);
+	printf(") rows=%.0f cost=%.2f..%.2f\n",
+		   path->parent->rows, path->startup_cost, path->total_cost);
+
+	if (path->pathkeys)
+	{
+		for (i = 0; i < indent; i++)
+			printf("\t");
+		printf("  pathkeys: ");
+		print_pathkeys(path->pathkeys, root->rtable);
+	}
+
 	if (join)
 	{
-		jp = (JoinPath *) path;
+		JoinPath   *jp = (JoinPath *) path;
 
-		printf("%s rows=%.0f cost=%.2f..%.2f\n",
-			   ptype, path->parent->rows,
-			   path->startup_cost, path->total_cost);
+		for (i = 0; i < indent; i++)
+			printf("\t");
+		printf("  clauses: ");
+		print_restrictclauses(root, jp->joinrestrictinfo);
+		printf("\n");
 
-		if (path->pathkeys)
+		if (nodeTag(path) == T_MergePath)
 		{
-			for (i = 0; i < indent; i++)
-				printf("\t");
-			printf("  pathkeys=");
-			print_pathkeys(path->pathkeys, root->rtable);
-		}
+			MergePath  *mp = (MergePath *) path;
 
-		switch (nodeTag(path))
-		{
-			case T_MergePath:
-			case T_HashPath:
+			if (mp->outersortkeys || mp->innersortkeys)
+			{
 				for (i = 0; i < indent; i++)
 					printf("\t");
-				printf("  clauses=(");
-				print_joinclauses(root, jp->joinrestrictinfo);
-				printf(")\n");
-
-				if (nodeTag(path) == T_MergePath)
-				{
-					MergePath  *mp = (MergePath *) path;
-
-					if (mp->outersortkeys || mp->innersortkeys)
-					{
-						for (i = 0; i < indent; i++)
-							printf("\t");
-						printf("  sortouter=%d sortinner=%d\n",
-							   ((mp->outersortkeys) ? 1 : 0),
-							   ((mp->innersortkeys) ? 1 : 0));
-					}
-				}
-				break;
-			default:
-				break;
+				printf("  sortouter=%d sortinner=%d\n",
+					   ((mp->outersortkeys) ? 1 : 0),
+					   ((mp->innersortkeys) ? 1 : 0));
+			}
 		}
+
 		print_path(root, jp->outerjoinpath, indent + 1);
 		print_path(root, jp->innerjoinpath, indent + 1);
 	}
-	else
-	{
-		int			relid = lfirsti(path->parent->relids);
-
-		printf("%s(%d) rows=%.0f cost=%.2f..%.2f\n",
-			   ptype, relid, path->parent->rows,
-			   path->startup_cost, path->total_cost);
-
-		if (path->pathkeys)
-		{
-			for (i = 0; i < indent; i++)
-				printf("\t");
-			printf("  pathkeys=");
-			print_pathkeys(path->pathkeys, root->rtable);
-		}
-	}
 }
 
-static void
+void
 debug_print_rel(Query *root, RelOptInfo *rel)
 {
 	List	   *l;
 
-	printf("(");
-	foreach(l, rel->relids)
-		printf("%d ", lfirsti(l));
+	printf("RELOPTINFO (");
+	print_relids(rel->relids);
 	printf("): rows=%.0f width=%d\n", rel->rows, rel->width);
 
+	if (rel->baserestrictinfo)
+	{
+		printf("\tbaserestrictinfo: ");
+		print_restrictclauses(root, rel->baserestrictinfo);
+		printf("\n");
+	}
+
+	foreach(l, rel->joininfo)
+	{
+		JoinInfo *j = (JoinInfo *) lfirst(l);
+
+		printf("\tjoininfo (");
+		print_relids(j->unjoined_relids);
+		printf("): ");
+		print_restrictclauses(root, j->jinfo_restrictinfo);
+		printf("\n");
+	}
+
 	printf("\tpath list:\n");
 	foreach(l, rel->pathlist)
 		print_path(root, lfirst(l), 1);
 	printf("\n\tcheapest startup path:\n");
 	print_path(root, rel->cheapest_startup_path, 1);
 	printf("\n\tcheapest total path:\n");
 	print_path(root, rel->cheapest_total_path, 1);
+	printf("\n");
+	fflush(stdout);
 }
 
 #endif	 /* OPTIMIZER_DEBUG */

src/backend/optimizer/path/joinrels.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.53 2001/05/20 20:28:18 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/joinrels.c,v 1.54 2001/10/18 16:11:41 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -374,6 +374,10 @@ make_jointree_rel(Query *root, Node *jtnode)
 		 */
 		set_cheapest(rel);
 
+#ifdef OPTIMIZER_DEBUG
+		debug_print_rel(root, rel);
+#endif
+
 		return rel;
 	}
 	else

src/backend/optimizer/path/pathkeys.c

@@ -11,7 +11,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.32 2001/03/22 06:16:14 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/pathkeys.c,v 1.33 2001/10/18 16:11:41 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -705,7 +705,7 @@ make_pathkeys_for_sortclauses(List *sortclauses,
  * This is a worthwhile savings because these routines will be invoked
  * many times when dealing with a many-relation query.
  */
-static void
+void
 cache_mergeclause_pathkeys(Query *root, RestrictInfo *restrictinfo)
 {
 	Node	   *key;