Adjust nestloop-with-inner-indexscan plan generation so that we catch

some cases of redundant clauses that were formerly not caught.  We have
to special-case this because the clauses involved never get attached to
the same join restrictlist and so the existing logic does not notice
that they are redundant.

Author: tglsfdc

src/backend/nodes/list.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.49 2003/05/28 22:32:49 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.50 2003/06/15 22:51:45 tgl Exp $
  *
  * NOTES
  *	  XXX a few of the following functions are duplicated to handle
@@ -358,6 +358,21 @@ llast(List *l)
 	return lfirst(l);
 }
 
+/*
+ *	llastnode
+ *
+ *	Get the last node of l ... NIL if empty list
+ */
+List *
+llastnode(List *l)
+{
+	if (l == NIL)
+		return NIL;
+	while (lnext(l) != NIL)
+		l = lnext(l);
+	return l;
+}
+
 /*
  *	freeList
  *

src/backend/nodes/outfuncs.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.207 2003/06/06 15:04:02 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.208 2003/06/15 22:51:45 tgl Exp $
  *
  * NOTES
  *	  Every node type that can appear in stored rules' parsetrees *must*
@@ -933,6 +933,7 @@ _outIndexPath(StringInfo str, IndexPath *node)
 
 	WRITE_NODE_FIELD(indexinfo);
 	WRITE_NODE_FIELD(indexqual);
+	WRITE_NODE_FIELD(indexjoinclauses);
 	WRITE_ENUM_FIELD(indexscandir, ScanDirection);
 	WRITE_FLOAT_FIELD(rows, "%.2f");
 }
@@ -1034,6 +1035,7 @@ _outRestrictInfo(StringInfo str, RestrictInfo *node)
 {
 	WRITE_NODE_TYPE("RESTRICTINFO");
 
+	/* NB: this isn't a complete set of fields */
 	WRITE_NODE_FIELD(clause);
 	WRITE_BOOL_FIELD(ispusheddown);
 	WRITE_NODE_FIELD(subclauseindices);
@@ -1042,6 +1044,8 @@ _outRestrictInfo(StringInfo str, RestrictInfo *node)
 	WRITE_OID_FIELD(mergejoinoperator);
 	WRITE_OID_FIELD(left_sortop);
 	WRITE_OID_FIELD(right_sortop);
+	WRITE_NODE_FIELD(left_pathkey);
+	WRITE_NODE_FIELD(right_pathkey);
 	WRITE_OID_FIELD(hashjoinoperator);
 }
 

src/backend/optimizer/path/indxpath.c

@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.143 2003/05/28 22:32:49 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.144 2003/06/15 22:51:45 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -59,10 +59,10 @@ static bool match_or_subclause_to_indexkey(RelOptInfo *rel,
 							   IndexOptInfo *index,
 							   Expr *clause);
 static List *group_clauses_by_indexkey(RelOptInfo *rel, IndexOptInfo *index);
-static List *group_clauses_by_indexkey_for_join(RelOptInfo *rel,
-								IndexOptInfo *index,
-								Relids outer_relids,
-								bool isouterjoin);
+static List *group_clauses_by_indexkey_for_join(Query *root,
+								   RelOptInfo *rel, IndexOptInfo *index,
+								   Relids outer_relids,
+								   JoinType jointype, bool isouterjoin);
 static bool match_clause_to_indexcol(RelOptInfo *rel, IndexOptInfo *index,
 									 int indexcol, Oid opclass, Expr *clause);
 static bool match_join_clause_to_indexcol(RelOptInfo *rel, IndexOptInfo *index,
@@ -583,8 +583,10 @@ group_clauses_by_indexkey(RelOptInfo *rel, IndexOptInfo *index)
  * will already have been generated for it.)
  */
 static List *
-group_clauses_by_indexkey_for_join(RelOptInfo *rel, IndexOptInfo *index,
-								   Relids outer_relids, bool isouterjoin)
+group_clauses_by_indexkey_for_join(Query *root,
+								   RelOptInfo *rel, IndexOptInfo *index,
+								   Relids outer_relids,
+								   JoinType jointype, bool isouterjoin)
 {
 	FastList	clausegroup_list;
 	bool		jfound = false;
@@ -629,6 +631,24 @@ group_clauses_by_indexkey_for_join(RelOptInfo *rel, IndexOptInfo *index,
 			}
 		}
 
+		/*
+		 * If we found join clauses in more than one joininfo list, we may
+		 * now have clauses that are known redundant.  Get rid of 'em.
+		 * (There is no point in looking at restriction clauses, because
+		 * remove_redundant_join_clauses will never think they are
+		 * redundant, so we do this before adding restriction clauses to
+		 * the clause group.)
+		 */
+		if (FastListValue(&clausegroup) != NIL)
+		{
+			List *nl;
+
+			nl = remove_redundant_join_clauses(root,
+											   FastListValue(&clausegroup),
+											   jointype);
+			FastListFromList(&clausegroup, nl);
+		}
+
 		/* We can also use plain restriction clauses for the rel */
 		foreach(i, rel->baserestrictinfo)
 		{
@@ -1461,9 +1481,11 @@ best_inner_indexscan(Query *root, RelOptInfo *rel,
 			List	   *clausegroups;
 
 			/* find useful clauses for this index and outerjoin set */
-			clausegroups = group_clauses_by_indexkey_for_join(rel,
+			clausegroups = group_clauses_by_indexkey_for_join(root,
+															  rel,
 															  index,
 															  index_outer_relids,
+															  jointype,
 															  isouterjoin);
 			if (clausegroups)
 			{
@@ -1520,7 +1542,7 @@ make_innerjoin_index_path(Query *root,
 			   *allclauses,
 			   *l;
 
-	/* XXX this code ought to be merged with create_index_path? */
+	/* XXX perhaps this code should be merged with create_index_path? */
 
 	pathnode->path.pathtype = T_IndexScan;
 	pathnode->path.parent = rel;
@@ -1535,12 +1557,25 @@ make_innerjoin_index_path(Query *root,
 	/* Convert RestrictInfo nodes to indexquals the executor can handle */
 	indexquals = expand_indexqual_conditions(index, clausegroups);
 
+	/*
+	 * Also make a flattened list of the RestrictInfo nodes; createplan.c
+	 * will need this later.  We assume here that we can destructively
+	 * modify the passed-in clausegroups list structure.
+	 */
+	allclauses = NIL;
+	foreach(l, clausegroups)
+	{
+		/* nconc okay here since same clause couldn't be in two sublists */
+		allclauses = nconc(allclauses, (List *) lfirst(l));
+	}
+
 	/*
 	 * Note that we are making a pathnode for a single-scan indexscan;
-	 * therefore, both indexinfo and indexqual should be single-element lists.
+	 * therefore, indexinfo and indexqual should be single-element lists.
 	 */
 	pathnode->indexinfo = makeList1(index);
 	pathnode->indexqual = makeList1(indexquals);
+	pathnode->indexjoinclauses = makeList1(allclauses);
 
 	/* We don't actually care what order the index scans in ... */
 	pathnode->indexscandir = NoMovementScanDirection;
@@ -1558,17 +1593,9 @@ make_innerjoin_index_path(Query *root,
 	 * linking them into different lists, it should be sufficient to use
 	 * pointer comparison to remove duplicates.)
 	 *
-	 * We assume we can destructively modify the input sublists.
-	 *
 	 * Always assume the join type is JOIN_INNER; even if some of the
 	 * join clauses come from other contexts, that's not our problem.
 	 */
-	allclauses = NIL;
-	foreach(l, clausegroups)
-	{
-		/* nconc okay here since same clause couldn't be in two sublists */
-		allclauses = nconc(allclauses, (List *) lfirst(l));
-	}
 	allclauses = set_ptrUnion(rel->baserestrictinfo, allclauses);
 	pathnode->rows = rel->tuples *
 		restrictlist_selectivity(root,

src/backend/optimizer/path/orindxpath.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.50 2003/05/28 22:32:49 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/optimizer/path/orindxpath.c,v 1.51 2003/06/15 22:51:45 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -89,6 +89,9 @@ create_or_index_paths(Query *root, RelOptInfo *rel)
 				 */
 				pathnode->path.pathkeys = NIL;
 
+				/* It's not an innerjoin path. */
+				pathnode->indexjoinclauses = NIL;
+
 				/* We don't actually care what order the index scans in. */
 				pathnode->indexscandir = NoMovementScanDirection;