Fix ILIKE to honor collation when working in single-byte encodings.

The original collation patch only fixed the multi-byte code path.
This change also ensures that ILIKE's idea of the case-folding rules
is exactly the same as str_tolower's.

diff --git a/src/backend/utils/adt/like.c b/src/backend/utils/adt/like.c
index 1edbe88b74cb232e91f523337ad7ab491fbbb03f..b060faa6a9b66ac22408dacb1d03c8116b054db4 100644 (file)
--- a/src/backend/utils/adt/like.c
+++ b/src/backend/utils/adt/like.c
@@ -19,8 +19,10 @@
 
 #include <ctype.h>
 
+#include "catalog/pg_collation.h"
 #include "mb/pg_wchar.h"
 #include "utils/builtins.h"
+#include "utils/pg_locale.h"
 
 
 #define LIKE_TRUE                      1
@@ -28,15 +30,19 @@
 #define LIKE_ABORT                     (-1)
 
 
-static int SB_MatchText(char *t, int tlen, char *p, int plen);
+static int SB_MatchText(char *t, int tlen, char *p, int plen,
+                        pg_locale_t locale, bool locale_is_c);
 static text *SB_do_like_escape(text *, text *);
 
-static int MB_MatchText(char *t, int tlen, char *p, int plen);
+static int MB_MatchText(char *t, int tlen, char *p, int plen,
+                        pg_locale_t locale, bool locale_is_c);
 static text *MB_do_like_escape(text *, text *);
 
-static int UTF8_MatchText(char *t, int tlen, char *p, int plen);
+static int UTF8_MatchText(char *t, int tlen, char *p, int plen,
+                          pg_locale_t locale, bool locale_is_c);
 
-static int SB_IMatchText(char *t, int tlen, char *p, int plen);
+static int SB_IMatchText(char *t, int tlen, char *p, int plen,
+                         pg_locale_t locale, bool locale_is_c);
 
 static int GenericMatchText(char *s, int slen, char *p, int plen);
 static int Generic_Text_IC_like(text *str, text *pat, Oid collation);
@@ -78,6 +84,24 @@ wchareq(char *p1, char *p2)
  * comparison. This should be revisited when we install better locale support.
  */
 
+/*
+ * We do handle case-insensitive matching for single-byte encodings using
+ * fold-on-the-fly processing, however.
+ */
+static char
+SB_lower_char(unsigned char c, pg_locale_t locale, bool locale_is_c)
+{
+   if (locale_is_c)
+       return pg_ascii_tolower(c);
+#ifdef HAVE_LOCALE_T
+   else if (locale)
+       return tolower_l(c, locale);
+#endif
+   else
+       return pg_tolower(c);
+}
+
+
 #define NextByte(p, plen)  ((p)++, (plen)--)
 
 /* Set up to compile like_match.c for multibyte characters */
@@ -107,7 +131,7 @@ wchareq(char *p1, char *p2)
 #include "like_match.c"
 
 /* setup to compile like_match.c for single byte case insensitive matches */
-#define MATCH_LOWER
+#define MATCH_LOWER(t) SB_lower_char((unsigned char) (t), locale, locale_is_c)
 #define NextChar(p, plen) NextByte((p), (plen))
 #define MatchText SB_IMatchText
 
@@ -121,15 +145,16 @@ wchareq(char *p1, char *p2)
 
 #include "like_match.c"
 
+/* Generic for all cases not requiring inline case-folding */
 static inline int
 GenericMatchText(char *s, int slen, char *p, int plen)
 {
    if (pg_database_encoding_max_length() == 1)
-       return SB_MatchText(s, slen, p, plen);
+       return SB_MatchText(s, slen, p, plen, 0, true);
    else if (GetDatabaseEncoding() == PG_UTF8)
-       return UTF8_MatchText(s, slen, p, plen);
+       return UTF8_MatchText(s, slen, p, plen, 0, true);
    else
-       return MB_MatchText(s, slen, p, plen);
+       return MB_MatchText(s, slen, p, plen, 0, true);
 }
 
 static inline int
@@ -142,8 +167,8 @@ Generic_Text_IC_like(text *str, text *pat, Oid collation)
 
    /*
     * For efficiency reasons, in the single byte case we don't call lower()
-    * on the pattern and text, but instead call to_lower on each character.
-    * In the multi-byte case we don't have much choice :-(
+    * on the pattern and text, but instead call SB_lower_char on each
+    * character.  In the multi-byte case we don't have much choice :-(
     */
 
    if (pg_database_encoding_max_length() > 1)
@@ -156,17 +181,42 @@ Generic_Text_IC_like(text *str, text *pat, Oid collation)
        s = VARDATA(str);
        slen = (VARSIZE(str) - VARHDRSZ);
        if (GetDatabaseEncoding() == PG_UTF8)
-           return UTF8_MatchText(s, slen, p, plen);
+           return UTF8_MatchText(s, slen, p, plen, 0, true);
        else
-           return MB_MatchText(s, slen, p, plen);
+           return MB_MatchText(s, slen, p, plen, 0, true);
    }
    else
    {
+       /*
+        * Here we need to prepare locale information for SB_lower_char.
+        * This should match the methods used in str_tolower().
+        */
+       pg_locale_t locale = 0;
+       bool    locale_is_c = false;
+
+       if (lc_ctype_is_c(collation))
+           locale_is_c = true;
+       else if (collation != DEFAULT_COLLATION_OID)
+       {
+           if (!OidIsValid(collation))
+           {
+               /*
+                * This typically means that the parser could not resolve a
+                * conflict of implicit collations, so report it that way.
+                */
+               ereport(ERROR,
+                       (errcode(ERRCODE_INDETERMINATE_COLLATION),
+                        errmsg("could not determine which collation to use for ILIKE"),
+                        errhint("Use the COLLATE clause to set the collation explicitly.")));
+           }
+           locale = pg_newlocale_from_collation(collation);
+       }
+
        p = VARDATA_ANY(pat);
        plen = VARSIZE_ANY_EXHDR(pat);
        s = VARDATA_ANY(str);
        slen = VARSIZE_ANY_EXHDR(str);
-       return SB_IMatchText(s, slen, p, plen);
+       return SB_IMatchText(s, slen, p, plen, locale, locale_is_c);
    }
 }
 
@@ -274,7 +324,7 @@ bytealike(PG_FUNCTION_ARGS)
    p = VARDATA_ANY(pat);
    plen = VARSIZE_ANY_EXHDR(pat);
 
-   result = (SB_MatchText(s, slen, p, plen) == LIKE_TRUE);
+   result = (SB_MatchText(s, slen, p, plen, 0, true) == LIKE_TRUE);
 
    PG_RETURN_BOOL(result);
 }
@@ -295,7 +345,7 @@ byteanlike(PG_FUNCTION_ARGS)
    p = VARDATA_ANY(pat);
    plen = VARSIZE_ANY_EXHDR(pat);
 
-   result = (SB_MatchText(s, slen, p, plen) != LIKE_TRUE);
+   result = (SB_MatchText(s, slen, p, plen, 0, true) != LIKE_TRUE);
 
    PG_RETURN_BOOL(result);
 }

diff --git a/src/backend/utils/adt/like_match.c b/src/backend/utils/adt/like_match.c
index 2a99e940170e58e9f038e331c2c9a35ea74608b6..214664116d7f8109051470f326b1830e6e136adb 100644 (file)
--- a/src/backend/utils/adt/like_match.c
+++ b/src/backend/utils/adt/like_match.c
@@ -5,7 +5,7 @@
  *
  * This file is included by like.c four times, to provide matching code for
  * (1) single-byte encodings, (2) UTF8, (3) other multi-byte encodings,
- * and (4) case insensitive matches in single byte encodings.
+ * and (4) case insensitive matches in single-byte encodings.
  * (UTF8 is a special case because we can use a much more efficient version
  * of NextChar than can be used for general multi-byte encodings.)
  *
@@ -14,7 +14,7 @@
  * NextChar
  * MatchText - to name of function wanted
  * do_like_escape - name of function if wanted - needs CHAREQ and CopyAdvChar
- * MATCH_LOWER - define for case (4), using to_lower on single-byte chars
+ * MATCH_LOWER - define for case (4) to specify case folding for 1-byte chars
  *
  * Copyright (c) 1996-2011, PostgreSQL Global Development Group
  *
@@ -70,13 +70,14 @@
  */
 
 #ifdef MATCH_LOWER
-#define GETCHAR(t) ((char) tolower((unsigned char) (t)))
+#define GETCHAR(t) MATCH_LOWER(t)
 #else
 #define GETCHAR(t) (t)
 #endif
 
 static int
-MatchText(char *t, int tlen, char *p, int plen)
+MatchText(char *t, int tlen, char *p, int plen,
+         pg_locale_t locale, bool locale_is_c)
 {
    /* Fast path for match-everything pattern */
    if (plen == 1 && *p == '%')
@@ -170,7 +171,8 @@ MatchText(char *t, int tlen, char *p, int plen)
            {
                if (GETCHAR(*t) == firstpat)
                {
-                   int         matched = MatchText(t, tlen, p, plen);
+                   int         matched = MatchText(t, tlen, p, plen,
+                                                   locale, locale_is_c);
 
                    if (matched != LIKE_FALSE)
                        return matched; /* TRUE or ABORT */