Fix matching of boolean index columns to sort ordering.
Normally, if we have a WHERE clause like "indexcol = constant", the planner will figure out that that index column can be ignored when determining whether the index has a desired sort ordering. But this failed to work for boolean index columns, because a condition like "boolcol = true" is canonicalized to just "boolcol" which does not give rise to an EquivalenceClass. Add a check to allow the same type of deduction to be made in this case too. Per a complaint from Dima Pavlov. Arguably this is a bug, but given the limited impact and the small number of complaints so far, I won't risk destabilizing plans in stable branches by back-patching. Patch by me, reviewed by Michael Paquier Discussion: https://postgr.es/m/1788.1481605684@sss.pgh.pa.us
This commit is contained in:
parent
83f2061dd0
commit
0777f7a2e8
|
@ -3025,6 +3025,52 @@ relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel,
|
|||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* indexcol_is_bool_constant_for_query
|
||||
*
|
||||
* If an index column is constrained to have a constant value by the query's
|
||||
* WHERE conditions, then it's irrelevant for sort-order considerations.
|
||||
* Usually that means we have a restriction clause WHERE indexcol = constant,
|
||||
* which gets turned into an EquivalenceClass containing a constant, which
|
||||
* is recognized as redundant by build_index_pathkeys(). But if the index
|
||||
* column is a boolean variable (or expression), then we are not going to
|
||||
* see WHERE indexcol = constant, because expression preprocessing will have
|
||||
* simplified that to "WHERE indexcol" or "WHERE NOT indexcol". So we are not
|
||||
* going to have a matching EquivalenceClass (unless the query also contains
|
||||
* "ORDER BY indexcol"). To allow such cases to work the same as they would
|
||||
* for non-boolean values, this function is provided to detect whether the
|
||||
* specified index column matches a boolean restriction clause.
|
||||
*/
|
||||
bool
|
||||
indexcol_is_bool_constant_for_query(IndexOptInfo *index, int indexcol)
|
||||
{
|
||||
ListCell *lc;
|
||||
|
||||
/* If the index isn't boolean, we can't possibly get a match */
|
||||
if (!IsBooleanOpfamily(index->opfamily[indexcol]))
|
||||
return false;
|
||||
|
||||
/* Check each restriction clause for the index's rel */
|
||||
foreach(lc, index->rel->baserestrictinfo)
|
||||
{
|
||||
RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
|
||||
|
||||
/*
|
||||
* As in match_clause_to_indexcol, never match pseudoconstants to
|
||||
* indexes. (It might be semantically okay to do so here, but the
|
||||
* odds of getting a match are negligible, so don't waste the cycles.)
|
||||
*/
|
||||
if (rinfo->pseudoconstant)
|
||||
continue;
|
||||
|
||||
/* See if we can match the clause's expression to the index column */
|
||||
if (match_boolean_index_clause((Node *) rinfo->clause, indexcol, index))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************
|
||||
* ---- ROUTINES TO CHECK OPERANDS ----
|
||||
|
|
|
@ -480,17 +480,30 @@ build_index_pathkeys(PlannerInfo *root,
|
|||
index->rel->relids,
|
||||
false);
|
||||
|
||||
if (cpathkey)
|
||||
{
|
||||
/*
|
||||
* If the sort key isn't already present in any EquivalenceClass, then
|
||||
* it's not an interesting sort order for this query. So we can stop
|
||||
* now --- lower-order sort keys aren't useful either.
|
||||
* We found the sort key in an EquivalenceClass, so it's relevant
|
||||
* for this query. Add it to list, unless it's redundant.
|
||||
*/
|
||||
if (!cpathkey)
|
||||
break;
|
||||
|
||||
/* Add to list unless redundant */
|
||||
if (!pathkey_is_redundant(cpathkey, retval))
|
||||
retval = lappend(retval, cpathkey);
|
||||
}
|
||||
else
|
||||
{
|
||||
/*
|
||||
* Boolean index keys might be redundant even if they do not
|
||||
* appear in an EquivalenceClass, because of our special treatment
|
||||
* of boolean equality conditions --- see the comment for
|
||||
* indexcol_is_bool_constant_for_query(). If that applies, we can
|
||||
* continue to examine lower-order index columns. Otherwise, the
|
||||
* sort key is not an interesting sort order for this query, so we
|
||||
* should stop considering index columns; any lower-order sort
|
||||
* keys won't be useful either.
|
||||
*/
|
||||
if (!indexcol_is_bool_constant_for_query(index, i))
|
||||
break;
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
|
|
@ -66,6 +66,8 @@ extern void create_index_paths(PlannerInfo *root, RelOptInfo *rel);
|
|||
extern bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel,
|
||||
List *restrictlist,
|
||||
List *exprlist, List *oprlist);
|
||||
extern bool indexcol_is_bool_constant_for_query(IndexOptInfo *index,
|
||||
int indexcol);
|
||||
extern bool match_index_to_operand(Node *operand, int indexcol,
|
||||
IndexOptInfo *index);
|
||||
extern void expand_indexqual_conditions(IndexOptInfo *index,
|
||||
|
|
|
@ -2952,6 +2952,48 @@ explain (costs off)
|
|||
Index Cond: ((thousand = 1) AND (tenthous = 1001))
|
||||
(2 rows)
|
||||
|
||||
--
|
||||
-- Check matching of boolean index columns to WHERE conditions and sort keys
|
||||
--
|
||||
create temp table boolindex (b bool, i int, unique(b, i), junk float);
|
||||
explain (costs off)
|
||||
select * from boolindex order by b, i limit 10;
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------
|
||||
Limit
|
||||
-> Index Scan using boolindex_b_i_key on boolindex
|
||||
(2 rows)
|
||||
|
||||
explain (costs off)
|
||||
select * from boolindex where b order by i limit 10;
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------
|
||||
Limit
|
||||
-> Index Scan using boolindex_b_i_key on boolindex
|
||||
Index Cond: (b = true)
|
||||
Filter: b
|
||||
(4 rows)
|
||||
|
||||
explain (costs off)
|
||||
select * from boolindex where b = true order by i desc limit 10;
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------
|
||||
Limit
|
||||
-> Index Scan Backward using boolindex_b_i_key on boolindex
|
||||
Index Cond: (b = true)
|
||||
Filter: b
|
||||
(4 rows)
|
||||
|
||||
explain (costs off)
|
||||
select * from boolindex where not b order by i limit 10;
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------
|
||||
Limit
|
||||
-> Index Scan using boolindex_b_i_key on boolindex
|
||||
Index Cond: (b = false)
|
||||
Filter: (NOT b)
|
||||
(4 rows)
|
||||
|
||||
--
|
||||
-- REINDEX (VERBOSE)
|
||||
--
|
||||
|
|
|
@ -1010,6 +1010,21 @@ RESET enable_indexscan;
|
|||
explain (costs off)
|
||||
select * from tenk1 where (thousand, tenthous) in ((1,1001), (null,null));
|
||||
|
||||
--
|
||||
-- Check matching of boolean index columns to WHERE conditions and sort keys
|
||||
--
|
||||
|
||||
create temp table boolindex (b bool, i int, unique(b, i), junk float);
|
||||
|
||||
explain (costs off)
|
||||
select * from boolindex order by b, i limit 10;
|
||||
explain (costs off)
|
||||
select * from boolindex where b order by i limit 10;
|
||||
explain (costs off)
|
||||
select * from boolindex where b = true order by i desc limit 10;
|
||||
explain (costs off)
|
||||
select * from boolindex where not b order by i limit 10;
|
||||
|
||||
--
|
||||
-- REINDEX (VERBOSE)
|
||||
--
|
||||
|
|
Loading…
Reference in New Issue