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- to v12 where the mistake
came in.

Discussion: https://postgr.es/m/CA+u7OA7nnGYy8rY0vdTe811NuA+Frr9nbcBO9u2Z+JxqNaud+g@mail.gmail.com

diff --git a/src/backend/utils/adt/like_support.c b/src/backend/utils/adt/like_support.c
index c8fec7863f410a1f0b468498beb701176e48c3ab..77cc37819657b7dfd5a79bc1171b5b1f2cabd064 100644 (file)
--- 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), &ltproc);
        greaterstr = make_greater_string(prefix, &ltproc, indexcollation);
        if (greaterstr)

diff --git a/src/test/regress/expected/btree_index.out b/src/test/regress/expected/btree_index.out
index acab8e0b115e89e5d41cf3ca10629ca7e5e39e6e..f567117a4662780d17449e8c69ea7ba999394e12 100644 (file)
--- 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 48eaf4fe42589ac257e50c0effd5e5ada44766e8..558dcae0ec7c5f9c4632f3a6417e7058927db48e 100644 (file)
--- 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.
 --