mirror of
https://git.postgresql.org/git/postgresql.git
synced 2025-02-11 19:20:40 +08:00
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.
This commit is contained in:
parent
65bd783614
commit
97ddfc9607
src/backend/optimizer
@ -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,
|
||||
|
@ -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)
|
||||
{
|
||||
|
Loading…
Reference in New Issue
Block a user