database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-15 19:21:59 +03:00
Code Activity

Ensure that EquivalenceClasses generated from ORDER BY keys contain proper

Browse Source 
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:
Tom Lane
2007-11-02 18:54:15 +00:00
parent 65bd783614
commit 97ddfc9607
2 changed files with 44 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
src/backend/optimizer/path/pathkeys.c
View File

@ -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,