Allow multibyte characters as escape in SIMILAR TO and SUBSTRING.

Previously, only a single-byte character was allowed as an
escape. This patch allows it to be a multi-byte character, though it
still must be a single character.

Reviewed by Heikki Linnakangas and Tom Lane.

diff --git a/src/backend/utils/adt/regexp.c b/src/backend/utils/adt/regexp.c
index caf45ef85f9717e989a19a21c1241c894b55d8ef..50b33f6b364528f6c70906b1ba299e18f60b992b 100644 (file)
--- a/src/backend/utils/adt/regexp.c
+++ b/src/backend/utils/adt/regexp.c
@@ -688,11 +688,16 @@ similar_escape(PG_FUNCTION_ARGS)
                elen = VARSIZE_ANY_EXHDR(esc_text);
                if (elen == 0)
                        e = NULL;                       /* no escape character */
-               else if (elen != 1)
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
-                                        errmsg("invalid escape string"),
-                                 errhint("Escape string must be empty or one character.")));
+               else
+               {
+                       int                     escape_mblen = pg_mbstrlen_with_len(e, elen);
+
+                       if (escape_mblen > 1)
+                               ereport(ERROR,
+                                               (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
+                                                errmsg("invalid escape string"),
+                                                errhint("Escape string must be empty or one character.")));
+               }
        }
 
        /*----------
@@ -724,6 +729,54 @@ similar_escape(PG_FUNCTION_ARGS)
        {
                char            pchar = *p;
 
+               /*
+                * If both the escape character and the current character from the
+                * pattern are multi-byte, we need to take the slow path.
+                *
+                * But if one of them is single-byte, we can process the pattern one
+                * byte at a time, ignoring multi-byte characters.  (This works
+                * because all server-encodings have the property that a valid
+                * multi-byte character representation cannot contain the
+                * representation of a valid single-byte character.)
+                */
+
+               if (elen > 1)
+               {
+                       int mblen = pg_mblen(p);
+                       if (mblen > 1)
+                       {
+                               /* slow, multi-byte path */
+                               if (afterescape)
+                               {
+                                       *r++ = '\\';
+                                       memcpy(r, p, mblen);
+                                       r += mblen;
+                                       afterescape = false;
+                               }
+                               else if (e && elen == mblen && memcmp(e, p, mblen) == 0)
+                               {
+                                       /* SQL99 escape character; do not send to output */
+                                       afterescape = true;
+                               }
+                               else
+                               {
+                                       /*
+                                        * We know it's a multi-byte character, so we don't need
+                                        * to do all the comparisons to single-byte characters
+                                        * that we do below.
+                                        */
+                                       memcpy(r, p, mblen);
+                                       r += mblen;
+                               }
+
+                               p += mblen;
+                               plen -= mblen;
+
+                               continue;
+                       }
+               }
+
+               /* fast path */
                if (afterescape)
                {
                        if (pchar == '"' && !incharclass)       /* for SUBSTRING patterns */