Ensure that EquivalenceClasses generated from ORDER BY keys contain proper

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
index b48bd953894bc2f79375471ee3b1a3f4ef14287a..2ad31203697cd0c9898ef567032e84f74319899f 100644 (file)
--- 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
index 23099df6dc32a357e79b5d46ae422c6e1506e631..fb9b437174fb3f362dd3a879561201436e2484f9 100644 (file)
--- 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)
        {