src/backend/utils/adt/like.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * like.c
   4  *        like expression handling code.
   5  *
   6  *       NOTES
   7  *              A big hack of the regexp.c code!! Contributed by
   8  *              Keith Parks <emkxp01@mtcc.demon.co.uk> (7/95).
   9  *
  10  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  11  * Portions Copyright (c) 1994, Regents of the University of California
  12  *
  13  * IDENTIFICATION
  14  *      $PostgreSQL$
  15  *
  16  *-------------------------------------------------------------------------
  17  */
  18 #include "postgres.h"
  19
  20 #include <ctype.h>
  21
  22 #include "mb/pg_wchar.h"
  23 #include "utils/builtins.h"
  24
  25
  26 #define LIKE_TRUE                                               1
  27 #define LIKE_FALSE                                              0
  28 #define LIKE_ABORT                                              (-1)
  29
  30
  31 static int      SB_MatchText(char *t, int tlen, char *p, int plen);
  32 static text *SB_do_like_escape(text *, text *);
  33
  34 static int      MB_MatchText(char *t, int tlen, char *p, int plen);
  35 static text *MB_do_like_escape(text *, text *);
  36
  37 static int      UTF8_MatchText(char *t, int tlen, char *p, int plen);
  38
  39 static int      SB_IMatchText(char *t, int tlen, char *p, int plen);
  40
  41 static int      GenericMatchText(char *s, int slen, char *p, int plen);
  42 static int      Generic_Text_IC_like(text *str, text *pat);
  43
  44 /*--------------------
  45  * Support routine for MatchText. Compares given multibyte streams
  46  * as wide characters. If they match, returns 1 otherwise returns 0.
  47  *--------------------
  48  */
  49 static inline int
  50 wchareq(char *p1, char *p2)
  51 {
  52         int                     p1_len;
  53
  54         /* Optimization:  quickly compare the first byte. */
  55         if (*p1 != *p2)
  56                 return 0;
  57
  58         p1_len = pg_mblen(p1);
  59         if (pg_mblen(p2) != p1_len)
  60                 return 0;
  61
  62         /* They are the same length */
  63         while (p1_len--)
  64         {
  65                 if (*p1++ != *p2++)
  66                         return 0;
  67         }
  68         return 1;
  69 }
  70
  71 /*
  72  * Formerly we had a routine iwchareq() here that tried to do case-insensitive
  73  * comparison of multibyte characters.  It did not work at all, however,
  74  * because it relied on tolower() which has a single-byte API ... and
  75  * towlower() wouldn't be much better since we have no suitably cheap way
  76  * of getting a single character transformed to the system's wchar_t format.
  77  * So now, we just downcase the strings using lower() and apply regular LIKE
  78  * comparison.  This should be revisited when we install better locale support.
  79  */
  80
  81 #define NextByte(p, plen)       ((p)++, (plen)--)
  82
  83 /* Set up to compile like_match.c for multibyte characters */
  84 #define CHAREQ(p1, p2) wchareq((p1), (p2))
  85 #define NextChar(p, plen) \
  86         do { int __l = pg_mblen(p); (p) +=__l; (plen) -=__l; } while (0)
  87 #define CopyAdvChar(dst, src, srclen) \
  88         do { int __l = pg_mblen(src); \
  89                  (srclen) -= __l; \
  90                  while (__l-- > 0) \
  91                          *(dst)++ = *(src)++; \
  92            } while (0)
  93
  94 #define MatchText       MB_MatchText
  95 #define do_like_escape  MB_do_like_escape
  96
  97 #include "like_match.c"
  98
  99 /* Set up to compile like_match.c for single-byte characters */
 100 #define CHAREQ(p1, p2) (*(p1) == *(p2))
 101 #define NextChar(p, plen) NextByte((p), (plen))
 102 #define CopyAdvChar(dst, src, srclen) (*(dst)++ = *(src)++, (srclen)--)
 103
 104 #define MatchText       SB_MatchText
 105 #define do_like_escape  SB_do_like_escape
 106
 107 #include "like_match.c"
 108
 109 /* setup to compile like_match.c for single byte case insensitive matches */
 110 #define MATCH_LOWER
 111 #define NextChar(p, plen) NextByte((p), (plen))
 112 #define MatchText SB_IMatchText
 113
 114 #include "like_match.c"
 115
 116 /* setup to compile like_match.c for UTF8 encoding, using fast NextChar */
 117
 118 #define NextChar(p, plen) \
 119         do { (p)++; (plen)--; } while ((plen) > 0 && (*(p) & 0xC0) == 0x80 )
 120 #define MatchText       UTF8_MatchText
 121
 122 #include "like_match.c"
 123
 124 static inline int
 125 GenericMatchText(char *s, int slen, char *p, int plen)
 126 {
 127         if (pg_database_encoding_max_length() == 1)
 128                 return SB_MatchText(s, slen, p, plen);
 129         else if (GetDatabaseEncoding() == PG_UTF8)
 130                 return UTF8_MatchText(s, slen, p, plen);
 131         else
 132                 return MB_MatchText(s, slen, p, plen);
 133 }
 134
 135 static inline int
 136 Generic_Text_IC_like(text *str, text *pat)
 137 {
 138         char       *s,
 139                            *p;
 140         int                     slen,
 141                                 plen;
 142
 143         /*
 144          * For efficiency reasons, in the single byte case we don't call lower()
 145          * on the pattern and text, but instead call to_lower on each character.
 146          * In the multi-byte case we don't have much choice :-(
 147          */
 148
 149         if (pg_database_encoding_max_length() > 1)
 150         {
 151                 /* lower's result is never packed, so OK to use old macros here */
 152                 pat = DatumGetTextP(DirectFunctionCall1(lower, PointerGetDatum(pat)));
 153                 p = VARDATA(pat);
 154                 plen = (VARSIZE(pat) - VARHDRSZ);
 155                 str = DatumGetTextP(DirectFunctionCall1(lower, PointerGetDatum(str)));
 156                 s = VARDATA(str);
 157                 slen = (VARSIZE(str) - VARHDRSZ);
 158                 if (GetDatabaseEncoding() == PG_UTF8)
 159                         return UTF8_MatchText(s, slen, p, plen);
 160                 else
 161                         return MB_MatchText(s, slen, p, plen);
 162         }
 163         else
 164         {
 165                 p = VARDATA_ANY(pat);
 166                 plen = VARSIZE_ANY_EXHDR(pat);
 167                 s = VARDATA_ANY(str);
 168                 slen = VARSIZE_ANY_EXHDR(str);
 169                 return SB_IMatchText(s, slen, p, plen);
 170         }
 171 }
 172
 173 /*
 174  *      interface routines called by the function manager
 175  */
 176
 177 Datum
 178 namelike(PG_FUNCTION_ARGS)
 179 {
 180         Name            str = PG_GETARG_NAME(0);
 181         text       *pat = PG_GETARG_TEXT_PP(1);
 182         bool            result;
 183         char       *s,
 184                            *p;
 185         int                     slen,
 186                                 plen;
 187
 188         s = NameStr(*str);
 189         slen = strlen(s);
 190         p = VARDATA_ANY(pat);
 191         plen = VARSIZE_ANY_EXHDR(pat);
 192
 193         result = (GenericMatchText(s, slen, p, plen) == LIKE_TRUE);
 194
 195         PG_RETURN_BOOL(result);
 196 }
 197
 198 Datum
 199 namenlike(PG_FUNCTION_ARGS)
 200 {
 201         Name            str = PG_GETARG_NAME(0);
 202         text       *pat = PG_GETARG_TEXT_PP(1);
 203         bool            result;
 204         char       *s,
 205                            *p;
 206         int                     slen,
 207                                 plen;
 208
 209         s = NameStr(*str);
 210         slen = strlen(s);
 211         p = VARDATA_ANY(pat);
 212         plen = VARSIZE_ANY_EXHDR(pat);
 213
 214         result = (GenericMatchText(s, slen, p, plen) != LIKE_TRUE);
 215
 216         PG_RETURN_BOOL(result);
 217 }
 218
 219 Datum
 220 textlike(PG_FUNCTION_ARGS)
 221 {
 222         text       *str = PG_GETARG_TEXT_PP(0);
 223         text       *pat = PG_GETARG_TEXT_PP(1);
 224         bool            result;
 225         char       *s,
 226                            *p;
 227         int                     slen,
 228                                 plen;
 229
 230         s = VARDATA_ANY(str);
 231         slen = VARSIZE_ANY_EXHDR(str);
 232         p = VARDATA_ANY(pat);
 233         plen = VARSIZE_ANY_EXHDR(pat);
 234
 235         result = (GenericMatchText(s, slen, p, plen) == LIKE_TRUE);
 236
 237         PG_RETURN_BOOL(result);
 238 }
 239
 240 Datum
 241 textnlike(PG_FUNCTION_ARGS)
 242 {
 243         text       *str = PG_GETARG_TEXT_PP(0);
 244         text       *pat = PG_GETARG_TEXT_PP(1);
 245         bool            result;
 246         char       *s,
 247                            *p;
 248         int                     slen,
 249                                 plen;
 250
 251         s = VARDATA_ANY(str);
 252         slen = VARSIZE_ANY_EXHDR(str);
 253         p = VARDATA_ANY(pat);
 254         plen = VARSIZE_ANY_EXHDR(pat);
 255
 256         result = (GenericMatchText(s, slen, p, plen) != LIKE_TRUE);
 257
 258         PG_RETURN_BOOL(result);
 259 }
 260
 261 Datum
 262 bytealike(PG_FUNCTION_ARGS)
 263 {
 264         bytea      *str = PG_GETARG_BYTEA_PP(0);
 265         bytea      *pat = PG_GETARG_BYTEA_PP(1);
 266         bool            result;
 267         char       *s,
 268                            *p;
 269         int                     slen,
 270                                 plen;
 271
 272         s = VARDATA_ANY(str);
 273         slen = VARSIZE_ANY_EXHDR(str);
 274         p = VARDATA_ANY(pat);
 275         plen = VARSIZE_ANY_EXHDR(pat);
 276
 277         result = (SB_MatchText(s, slen, p, plen) == LIKE_TRUE);
 278
 279         PG_RETURN_BOOL(result);
 280 }
 281
 282 Datum
 283 byteanlike(PG_FUNCTION_ARGS)
 284 {
 285         bytea      *str = PG_GETARG_BYTEA_PP(0);
 286         bytea      *pat = PG_GETARG_BYTEA_PP(1);
 287         bool            result;
 288         char       *s,
 289                            *p;
 290         int                     slen,
 291                                 plen;
 292
 293         s = VARDATA_ANY(str);
 294         slen = VARSIZE_ANY_EXHDR(str);
 295         p = VARDATA_ANY(pat);
 296         plen = VARSIZE_ANY_EXHDR(pat);
 297
 298         result = (SB_MatchText(s, slen, p, plen) != LIKE_TRUE);
 299
 300         PG_RETURN_BOOL(result);
 301 }
 302
 303 /*
 304  * Case-insensitive versions
 305  */
 306
 307 Datum
 308 nameiclike(PG_FUNCTION_ARGS)
 309 {
 310         Name            str = PG_GETARG_NAME(0);
 311         text       *pat = PG_GETARG_TEXT_PP(1);
 312         bool            result;
 313         text       *strtext;
 314
 315         strtext = DatumGetTextP(DirectFunctionCall1(name_text,
 316                                                                                                 NameGetDatum(str)));
 317         result = (Generic_Text_IC_like(strtext, pat) == LIKE_TRUE);
 318
 319         PG_RETURN_BOOL(result);
 320 }
 321
 322 Datum
 323 nameicnlike(PG_FUNCTION_ARGS)
 324 {
 325         Name            str = PG_GETARG_NAME(0);
 326         text       *pat = PG_GETARG_TEXT_PP(1);
 327         bool            result;
 328         text       *strtext;
 329
 330         strtext = DatumGetTextP(DirectFunctionCall1(name_text,
 331                                                                                                 NameGetDatum(str)));
 332         result = (Generic_Text_IC_like(strtext, pat) != LIKE_TRUE);
 333
 334         PG_RETURN_BOOL(result);
 335 }
 336
 337 Datum
 338 texticlike(PG_FUNCTION_ARGS)
 339 {
 340         text       *str = PG_GETARG_TEXT_PP(0);
 341         text       *pat = PG_GETARG_TEXT_PP(1);
 342         bool            result;
 343
 344         result = (Generic_Text_IC_like(str, pat) == LIKE_TRUE);
 345
 346         PG_RETURN_BOOL(result);
 347 }
 348
 349 Datum
 350 texticnlike(PG_FUNCTION_ARGS)
 351 {
 352         text       *str = PG_GETARG_TEXT_PP(0);
 353         text       *pat = PG_GETARG_TEXT_PP(1);
 354         bool            result;
 355
 356         result = (Generic_Text_IC_like(str, pat) != LIKE_TRUE);
 357
 358         PG_RETURN_BOOL(result);
 359 }
 360
 361 /*
 362  * like_escape() --- given a pattern and an ESCAPE string,
 363  * convert the pattern to use Postgres' standard backslash escape convention.
 364  */
 365 Datum
 366 like_escape(PG_FUNCTION_ARGS)
 367 {
 368         text       *pat = PG_GETARG_TEXT_PP(0);
 369         text       *esc = PG_GETARG_TEXT_PP(1);
 370         text       *result;
 371
 372         if (pg_database_encoding_max_length() == 1)
 373                 result = SB_do_like_escape(pat, esc);
 374         else
 375                 result = MB_do_like_escape(pat, esc);
 376
 377         PG_RETURN_TEXT_P(result);
 378 }
 379
 380 /*
 381  * like_escape_bytea() --- given a pattern and an ESCAPE string,
 382  * convert the pattern to use Postgres' standard backslash escape convention.
 383  */
 384 Datum
 385 like_escape_bytea(PG_FUNCTION_ARGS)
 386 {
 387         bytea      *pat = PG_GETARG_BYTEA_PP(0);
 388         bytea      *esc = PG_GETARG_BYTEA_PP(1);
 389         bytea      *result = SB_do_like_escape((text *) pat, (text *) esc);
 390
 391         PG_RETURN_BYTEA_P((bytea *) result);
 392 }