From bffe18e3e7dbb3c159361e62478c324ebe3041ec Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 19 Nov 2019 17:03:26 -0500 Subject: [PATCH] Fix corner-case failure in match_pattern_prefix(). The planner's optimization code for LIKE and regex operators could error out with a complaint like "no = operator for opfamily NNN" if someone created a binary-compatible index (for example, a bpchar_ops index on a text column) on the LIKE's left argument. This is a consequence of careless refactoring in commit 74dfe58a5. The old code in match_special_index_operator only accepted specific combinations of the pattern operator and the index opclass, thereby indirectly guaranteeing that the opclass would have a comparison operator with the same LHS input type as the pattern operator. While moving the logic out to a planner support function, I simplified that test in a way that no longer guarantees that. Really though we'd like an altogether weaker dependency on the opclass, so rather than put back exactly the old code, just allow lookup failure. I have in mind now to rewrite this logic completely, but this is the minimum change needed to fix the bug in v12. Per report from Manuel Rigger. Back-patch to v12 where the mistake came in. Discussion: https://postgr.es/m/CA+u7OA7nnGYy8rY0vdTe811NuA+Frr9nbcBO9u2Z+JxqNaud+g@mail.gmail.com --- src/backend/utils/adt/like_support.c | 11 ++-- src/test/regress/expected/btree_index.out | 68 +++++++++++++++++++++++ src/test/regress/sql/btree_index.sql | 20 +++++++ 3 files changed, 95 insertions(+), 4 deletions(-) diff --git a/src/backend/utils/adt/like_support.c b/src/backend/utils/adt/like_support.c index c8fec7863f..77cc378196 100644 --- a/src/backend/utils/adt/like_support.c +++ b/src/backend/utils/adt/like_support.c @@ -265,7 +265,7 @@ match_pattern_prefix(Node *leftop, * pattern-matching is not supported with nondeterministic collations. (We * could also error out here, but by doing it later we get more precise * error messages.) (It should be possible to support at least - * Pattern_Prefix_Exact, but no point as along as the actual + * Pattern_Prefix_Exact, but no point as long as the actual * pattern-matching implementations don't support it.) * * expr_coll is not set for a non-collation-aware data type such as bytea. @@ -357,13 +357,16 @@ match_pattern_prefix(Node *leftop, /* * If we found an exact-match pattern, generate an "=" indexqual. + * + * (Despite the checks above, we might fail to find a suitable operator in + * some cases with binary-compatible opclasses. Just punt if so.) */ if (pstatus == Pattern_Prefix_Exact) { oproid = get_opfamily_member(opfamily, ldatatype, rdatatype, BTEqualStrategyNumber); if (oproid == InvalidOid) - elog(ERROR, "no = operator for opfamily %u", opfamily); + return NIL; expr = make_opclause(oproid, BOOLOID, false, (Expr *) leftop, (Expr *) prefix, InvalidOid, indexcollation); @@ -379,7 +382,7 @@ match_pattern_prefix(Node *leftop, oproid = get_opfamily_member(opfamily, ldatatype, rdatatype, BTGreaterEqualStrategyNumber); if (oproid == InvalidOid) - elog(ERROR, "no >= operator for opfamily %u", opfamily); + return NIL; expr = make_opclause(oproid, BOOLOID, false, (Expr *) leftop, (Expr *) prefix, InvalidOid, indexcollation); @@ -396,7 +399,7 @@ match_pattern_prefix(Node *leftop, oproid = get_opfamily_member(opfamily, ldatatype, rdatatype, BTLessStrategyNumber); if (oproid == InvalidOid) - elog(ERROR, "no < operator for opfamily %u", opfamily); + return result; fmgr_info(get_opcode(oproid), <proc); greaterstr = make_greater_string(prefix, <proc, indexcollation); if (greaterstr) diff --git a/src/test/regress/expected/btree_index.out b/src/test/regress/expected/btree_index.out index acab8e0b11..f567117a46 100644 --- a/src/test/regress/expected/btree_index.out +++ b/src/test/regress/expected/btree_index.out @@ -198,6 +198,74 @@ select proname from pg_proc where proname ilike 'ri%foo' order by 1; reset enable_seqscan; reset enable_indexscan; reset enable_bitmapscan; +-- Also check LIKE optimization with binary-compatible cases +create temp table btree_bpchar (f1 text collate "C"); +create index on btree_bpchar(f1 bpchar_ops); +insert into btree_bpchar values ('foo'), ('fool'), ('bar'), ('quux'); +-- doesn't match index: +explain (costs off) +select * from btree_bpchar where f1 like 'foo'; + QUERY PLAN +------------------------------- + Seq Scan on btree_bpchar + Filter: (f1 ~~ 'foo'::text) +(2 rows) + +select * from btree_bpchar where f1 like 'foo'; + f1 +----- + foo +(1 row) + +explain (costs off) +select * from btree_bpchar where f1 like 'foo%'; + QUERY PLAN +-------------------------------- + Seq Scan on btree_bpchar + Filter: (f1 ~~ 'foo%'::text) +(2 rows) + +select * from btree_bpchar where f1 like 'foo%'; + f1 +------ + foo + fool +(2 rows) + +-- these do match the index: +explain (costs off) +select * from btree_bpchar where f1::bpchar like 'foo'; + QUERY PLAN +---------------------------------------------------- + Bitmap Heap Scan on btree_bpchar + Filter: ((f1)::bpchar ~~ 'foo'::text) + -> Bitmap Index Scan on btree_bpchar_f1_idx + Index Cond: ((f1)::bpchar = 'foo'::bpchar) +(4 rows) + +select * from btree_bpchar where f1::bpchar like 'foo'; + f1 +----- + foo +(1 row) + +explain (costs off) +select * from btree_bpchar where f1::bpchar like 'foo%'; + QUERY PLAN +------------------------------------------------------------------------------------------ + Bitmap Heap Scan on btree_bpchar + Filter: ((f1)::bpchar ~~ 'foo%'::text) + -> Bitmap Index Scan on btree_bpchar_f1_idx + Index Cond: (((f1)::bpchar >= 'foo'::bpchar) AND ((f1)::bpchar < 'fop'::bpchar)) +(4 rows) + +select * from btree_bpchar where f1::bpchar like 'foo%'; + f1 +------ + foo + fool +(2 rows) + -- -- Test B-tree fast path (cache rightmost leaf page) optimization. -- diff --git a/src/test/regress/sql/btree_index.sql b/src/test/regress/sql/btree_index.sql index 48eaf4fe42..558dcae0ec 100644 --- a/src/test/regress/sql/btree_index.sql +++ b/src/test/regress/sql/btree_index.sql @@ -83,6 +83,26 @@ reset enable_seqscan; reset enable_indexscan; reset enable_bitmapscan; +-- Also check LIKE optimization with binary-compatible cases + +create temp table btree_bpchar (f1 text collate "C"); +create index on btree_bpchar(f1 bpchar_ops); +insert into btree_bpchar values ('foo'), ('fool'), ('bar'), ('quux'); +-- doesn't match index: +explain (costs off) +select * from btree_bpchar where f1 like 'foo'; +select * from btree_bpchar where f1 like 'foo'; +explain (costs off) +select * from btree_bpchar where f1 like 'foo%'; +select * from btree_bpchar where f1 like 'foo%'; +-- these do match the index: +explain (costs off) +select * from btree_bpchar where f1::bpchar like 'foo'; +select * from btree_bpchar where f1::bpchar like 'foo'; +explain (costs off) +select * from btree_bpchar where f1::bpchar like 'foo%'; +select * from btree_bpchar where f1::bpchar like 'foo%'; + -- -- Test B-tree fast path (cache rightmost leaf page) optimization. --