Fix similar_escape() to convert parentheses to non-capturing style.

This is needed to avoid unwanted interference with SUBSTRING behavior,
as per bug #5257 from Roman Kononov.  Also, add some basic intelligence
about character classes (bracket expressions) since we now have several
behaviors that aren't appropriate inside a character class.

As with the previous patch in this area, I'm reluctant to back-patch
since it might affect applications that are relying on the prior
behavior.

diff --git a/src/backend/utils/adt/regexp.c b/src/backend/utils/adt/regexp.c
index ca61d5637f960f99dc4e711f964b0b380ed42c78..cbffcdb183508f038ef7424c68adff6295332fec 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.85 2010/01/02 16:57:55 momjian Exp $
+ *   $PostgreSQL: pgsql/src/backend/utils/adt/regexp.c,v 1.86 2010/01/02 20:59:16 tgl Exp $
  *
  *     Alistair Crooks added the code for the regex caching
  *     agc - cached the regular expressions used - there's a good chance
@@ -640,6 +640,7 @@ similar_escape(PG_FUNCTION_ARGS)
    int         plen,
                elen;
    bool        afterescape = false;
+   bool        incharclass = false;
    int         nquotes = 0;
 
    /* This function is not strict, so must test explicitly */
@@ -682,10 +683,10 @@ similar_escape(PG_FUNCTION_ARGS)
     */
 
    /*
-    * We need room for the prefix/postfix plus as many as 2 output bytes per
-    * input byte
+    * We need room for the prefix/postfix plus as many as 3 output bytes per
+    * input byte; since the input is at most 1GB this can't overflow
     */
-   result = (text *) palloc(VARHDRSZ + 6 + 2 * plen);
+   result = (text *) palloc(VARHDRSZ + 6 + 3 * plen);
    r = VARDATA(result);
 
    *r++ = '^';
@@ -699,7 +700,7 @@ similar_escape(PG_FUNCTION_ARGS)
 
        if (afterescape)
        {
-           if (pchar == '"')   /* for SUBSTRING patterns */
+           if (pchar == '"' && !incharclass)   /* for SUBSTRING patterns */
                *r++ = ((nquotes++ % 2) == 0) ? '(' : ')';
            else
            {
@@ -713,6 +714,19 @@ similar_escape(PG_FUNCTION_ARGS)
            /* SQL99 escape character; do not send to output */
            afterescape = true;
        }
+       else if (incharclass)
+       {
+           if (pchar == '\\')
+               *r++ = '\\';
+           *r++ = pchar;
+           if (pchar == ']')
+               incharclass = false;
+       }
+       else if (pchar == '[')
+       {
+           *r++ = pchar;
+           incharclass = true;
+       }
        else if (pchar == '%')
        {
            *r++ = '.';
@@ -720,6 +734,13 @@ similar_escape(PG_FUNCTION_ARGS)
        }
        else if (pchar == '_')
            *r++ = '.';
+       else if (pchar == '(')
+       {
+           /* convert to non-capturing parenthesis */
+           *r++ = '(';
+           *r++ = '?';
+           *r++ = ':';
+       }
        else if (pchar == '\\' || pchar == '.' ||
                 pchar == '^' || pchar == '$')
        {