Ensure that EquivalenceClasses generated from ORDER BY keys contain proper

tglsfdc · tglsfdc · commit 97ddfc960738 · 2007-11-02T18:54:15.000Z
RelabelType nodes when the sort key is binary-compatible with the sort
operator rather than having exactly its input type.  We did this correctly
for index columns but not sort keys, leading to failure to notice that
a varchar index matches an ORDER BY request.  This requires a bit more work
in make_sort_from_pathkeys, but not anyplace else that I can find.
Per bug report and subsequent discussion.
diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c
@@ -11,7 +11,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/path/pathkeys.c,v 1.86 2007/10/27 05:45:43 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/path/pathkeys.c,v 1.87 2007/11/02 18:54:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -277,6 +277,30 @@ make_pathkey_from_sortinfo(PlannerInfo *root,
 		elog(ERROR, "could not find opfamilies for ordering operator %u",
 			 ordering_op);
 
+	/*
+	 * When dealing with binary-compatible opclasses, we have to ensure that
+	 * the exposed type of the expression tree matches the declared input
+	 * type of the opclass, except when that is a polymorphic type
+	 * (compare the behavior of parse_coerce.c).  This ensures that we can
+	 * correctly match the indexkey or sortclause expression to other
+	 * expressions we find in the query, because arguments of ordinary
+	 * operator expressions will be cast that way.  (We have to do this
+	 * for indexkeys because they are represented without any explicit
+	 * relabel in pg_index, and for sort clauses because the parser is
+	 * likewise cavalier about putting relabels on them.)
+	 */
+	if (exprType((Node *) expr) != opcintype &&
+		!IsPolymorphicType(opcintype))
+	{
+		/* Strip any existing RelabelType, and add a new one */
+		while (expr && IsA(expr, RelabelType))
+			expr = (Expr *) ((RelabelType *) expr)->arg;
+		expr = (Expr *) makeRelabelType(expr,
+										opcintype,
+										-1,
+										COERCE_DONTCARE);
+	}
+
 	/* Now find or create a matching EquivalenceClass */
 	eclass = get_eclass_for_sort_expr(root, expr, opcintype, opfamilies);
 
@@ -495,27 +519,6 @@ build_index_pathkeys(PlannerInfo *root,
 			indexprs_item = lnext(indexprs_item);
 		}
 
-		/*
-		 * When dealing with binary-compatible indexes, we have to ensure that
-		 * the exposed type of the expression tree matches the declared input
-		 * type of the opclass, except when that is a polymorphic type
-		 * (compare the behavior of parse_coerce.c).  This ensures that we can
-		 * correctly match the indexkey expression to expressions we find in
-		 * the query, because arguments of operators that could match the
-		 * index will be cast likewise.
-		 */
-		if (exprType((Node *) indexkey) != index->opcintype[i] &&
-			!IsPolymorphicType(index->opcintype[i]))
-		{
-			/* Strip any existing RelabelType, and add a new one */
-			while (indexkey && IsA(indexkey, RelabelType))
-				indexkey = (Expr *) ((RelabelType *) indexkey)->arg;
-			indexkey = (Expr *) makeRelabelType(indexkey,
-												index->opcintype[i],
-												-1,
-												COERCE_DONTCARE);
-		}
-
 		/* OK, make a canonical pathkey for this sort key */
 		cpathkey = make_pathkey_from_sortinfo(root,
 											  indexkey,
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
@@ -10,7 +10,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.231 2007/05/21 17:57:34 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.232 2007/11/02 18:54:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2756,12 +2756,30 @@ make_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree, List *pathkeys,
 
 			if (em->em_is_const || em->em_is_child)
 				continue;
+
 			tle = tlist_member((Node *) em->em_expr, tlist);
 			if (tle)
 			{
 				pk_datatype = em->em_datatype;
 				break;			/* found expr already in tlist */
 			}
+
+			/*
+			 * We can also use it if the pathkey expression is a relabel
+			 * of the tlist entry.  This is needed for binary-compatible
+			 * cases (cf. make_pathkey_from_sortinfo).
+			 */
+			if (IsA(em->em_expr, RelabelType))
+			{
+				Expr	   *rtarg = ((RelabelType *) em->em_expr)->arg;
+
+				tle = tlist_member((Node *) rtarg, tlist);
+				if (tle)
+				{
+					pk_datatype = em->em_datatype;
+					break;			/* found expr already in tlist */
+				}
+			}
 		}
 		if (!tle)
 		{

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`*`
`11`	`11`	`*`
`12`	`12`	`* IDENTIFICATION`
`13`		`- * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.231 2007/05/21 17:57:34 tgl Exp $`
	`13`	`+ * $PostgreSQL: pgsql/src/backend/optimizer/plan/createplan.c,v 1.232 2007/11/02 18:54:15 tgl Exp $`
`14`	`14`	`*`
`15`	`15`	`*-------------------------------------------------------------------------`
`16`	`16`	`*/`
`@@ -2756,12 +2756,30 @@ make_sort_from_pathkeys(PlannerInfo root, Plan lefttree, List *pathkeys,`
`2756`	`2756`
`2757`	`2757`	`if (em->em_is_const \|\| em->em_is_child)`
`2758`	`2758`	`continue;`
	`2759`	`+`
`2759`	`2760`	`tle = tlist_member((Node *) em->em_expr, tlist);`
`2760`	`2761`	`if (tle)`
`2761`	`2762`	`{`
`2762`	`2763`	`pk_datatype = em->em_datatype;`
`2763`	`2764`	`break; /* found expr already in tlist */`
`2764`	`2765`	`}`
	`2766`	`+`
	`2767`	`+ /*`
	`2768`	`+ * We can also use it if the pathkey expression is a relabel`
	`2769`	`+ * of the tlist entry. This is needed for binary-compatible`
	`2770`	`+ * cases (cf. make_pathkey_from_sortinfo).`
	`2771`	`+ */`
	`2772`	`+ if (IsA(em->em_expr, RelabelType))`
	`2773`	`+ {`
	`2774`	`+ Expr rtarg = ((RelabelType ) em->em_expr)->arg;`
	`2775`	`+`
	`2776`	`+ tle = tlist_member((Node *) rtarg, tlist);`
	`2777`	`+ if (tle)`
	`2778`	`+ {`
	`2779`	`+ pk_datatype = em->em_datatype;`
	`2780`	`+ break; /* found expr already in tlist */`
	`2781`	`+ }`
	`2782`	`+ }`
`2765`	`2783`	`}`
`2766`	`2784`	`if (!tle)`
`2767`	`2785`	`{`