Fix regexp substring matching (substring(string from pattern)) for the corner

case where there is a match to the pattern overall but the user has specified
a parenthesized subexpression and that subexpression hasn't got a match.
An example is substring('foo' from 'foo(bar)?').  This should return NULL,
since (bar) isn't matched, but it was mistakenly returning the whole-pattern
match instead (ie, 'foo').  Per bug #4044 from Rui Martins.

This has been broken since the beginning; patch in all supported versions.
The old behavior was sufficiently inconsistent that it's impossible to believe
anyone is depending on it.

diff --git a/src/backend/utils/adt/regexp.c b/src/backend/utils/adt/regexp.c
index 359fd33ceea30c7eb75d5d7dce9af255489d2fd6..4a96a1bb70c017cf5c9905f7ea2b8e0f5b5d5103 100644 (file)
--- a/src/backend/utils/adt/regexp.c
+++ b/src/backend/utils/adt/regexp.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/utils/adt/regexp.c,v 1.78 2008/01/01 19:45:52 momjian Exp $
+ *   $PostgreSQL: pgsql/src/backend/utils/adt/regexp.c,v 1.79 2008/03/19 02:40:37 tgl Exp $
  *
  *     Alistair Crooks added the code for the regex caching
  *     agc - cached the regular expressions used - there's a good chance
@@ -576,8 +576,13 @@ textregexsubstr(PG_FUNCTION_ARGS)
 {
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
-   bool        match;
+   regex_t    *re;
    regmatch_t  pmatch[2];
+   int         so,
+               eo;
+
+   /* Compile RE */
+   re = RE_compile_and_cache(p, regex_flavor);
 
    /*
     * We pass two regmatch_t structs to get info about the overall match and
@@ -585,34 +590,37 @@ textregexsubstr(PG_FUNCTION_ARGS)
     * is a parenthesized subexpression, we return what it matched; else
     * return what the whole regexp matched.
     */
-   match = RE_compile_and_execute(p,
-                                  VARDATA_ANY(s),
-                                  VARSIZE_ANY_EXHDR(s),
-                                  regex_flavor,
-                                  2, pmatch);
-
-   /* match? then return the substring matching the pattern */
-   if (match)
-   {
-       int         so,
-                   eo;
+   if (!RE_execute(re,
+                   VARDATA_ANY(s), VARSIZE_ANY_EXHDR(s),
+                   2, pmatch))
+       PG_RETURN_NULL();       /* definitely no match */
 
+   if (re->re_nsub > 0)
+   {
+       /* has parenthesized subexpressions, use the first one */
        so = pmatch[1].rm_so;
        eo = pmatch[1].rm_eo;
-       if (so < 0 || eo < 0)
-       {
-           /* no parenthesized subexpression */
-           so = pmatch[0].rm_so;
-           eo = pmatch[0].rm_eo;
-       }
-
-       return DirectFunctionCall3(text_substr,
-                                  PointerGetDatum(s),
-                                  Int32GetDatum(so + 1),
-                                  Int32GetDatum(eo - so));
    }
+   else
+   {
+       /* no parenthesized subexpression, use whole match */
+       so = pmatch[0].rm_so;
+       eo = pmatch[0].rm_eo;
+   }
+
+   /*
+    * It is possible to have a match to the whole pattern but no match
+    * for a subexpression; for example 'foo(bar)?' is considered to match
+    * 'foo' but there is no subexpression match.  So this extra test for
+    * match failure is not redundant.
+    */
+   if (so < 0 || eo < 0)
+       PG_RETURN_NULL();
 
-   PG_RETURN_NULL();
+   return DirectFunctionCall3(text_substr,
+                              PointerGetDatum(s),
+                              Int32GetDatum(so + 1),
+                              Int32GetDatum(eo - so));
 }
 
 /*