LCOV - code coverage report
Current view: top level - src/backend/utils/adt - like.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 87 140 62.1 %
Date: 2019-09-19 23:07:04 Functions: 11 16 68.8 %
Legend: Lines: hit not hit

          Line data    Source code
       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-2019, PostgreSQL Global Development Group
      11             :  * Portions Copyright (c) 1994, Regents of the University of California
      12             :  *
      13             :  * IDENTIFICATION
      14             :  *  src/backend/utils/adt/like.c
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "postgres.h"
      19             : 
      20             : #include <ctype.h>
      21             : 
      22             : #include "catalog/pg_collation.h"
      23             : #include "mb/pg_wchar.h"
      24             : #include "miscadmin.h"
      25             : #include "utils/builtins.h"
      26             : #include "utils/pg_locale.h"
      27             : 
      28             : 
      29             : #define LIKE_TRUE                       1
      30             : #define LIKE_FALSE                      0
      31             : #define LIKE_ABORT                      (-1)
      32             : 
      33             : 
      34             : static int  SB_MatchText(const char *t, int tlen, const char *p, int plen,
      35             :                          pg_locale_t locale, bool locale_is_c);
      36             : static text *SB_do_like_escape(text *, text *);
      37             : 
      38             : static int  MB_MatchText(const char *t, int tlen, const char *p, int plen,
      39             :                          pg_locale_t locale, bool locale_is_c);
      40             : static text *MB_do_like_escape(text *, text *);
      41             : 
      42             : static int  UTF8_MatchText(const char *t, int tlen, const char *p, int plen,
      43             :                            pg_locale_t locale, bool locale_is_c);
      44             : 
      45             : static int  SB_IMatchText(const char *t, int tlen, const char *p, int plen,
      46             :                           pg_locale_t locale, bool locale_is_c);
      47             : 
      48             : static int  GenericMatchText(const char *s, int slen, const char *p, int plen, Oid collation);
      49             : static int  Generic_Text_IC_like(text *str, text *pat, Oid collation);
      50             : 
      51             : /*--------------------
      52             :  * Support routine for MatchText. Compares given multibyte streams
      53             :  * as wide characters. If they match, returns 1 otherwise returns 0.
      54             :  *--------------------
      55             :  */
      56             : static inline int
      57         616 : wchareq(const char *p1, const char *p2)
      58             : {
      59             :     int         p1_len;
      60             : 
      61             :     /* Optimization:  quickly compare the first byte. */
      62         616 :     if (*p1 != *p2)
      63         464 :         return 0;
      64             : 
      65         152 :     p1_len = pg_mblen(p1);
      66         152 :     if (pg_mblen(p2) != p1_len)
      67           0 :         return 0;
      68             : 
      69             :     /* They are the same length */
      70         456 :     while (p1_len--)
      71             :     {
      72         152 :         if (*p1++ != *p2++)
      73           0 :             return 0;
      74             :     }
      75         152 :     return 1;
      76             : }
      77             : 
      78             : /*
      79             :  * Formerly we had a routine iwchareq() here that tried to do case-insensitive
      80             :  * comparison of multibyte characters.  It did not work at all, however,
      81             :  * because it relied on tolower() which has a single-byte API ... and
      82             :  * towlower() wouldn't be much better since we have no suitably cheap way
      83             :  * of getting a single character transformed to the system's wchar_t format.
      84             :  * So now, we just downcase the strings using lower() and apply regular LIKE
      85             :  * comparison.  This should be revisited when we install better locale support.
      86             :  */
      87             : 
      88             : /*
      89             :  * We do handle case-insensitive matching for single-byte encodings using
      90             :  * fold-on-the-fly processing, however.
      91             :  */
      92             : static char
      93           0 : SB_lower_char(unsigned char c, pg_locale_t locale, bool locale_is_c)
      94             : {
      95           0 :     if (locale_is_c)
      96           0 :         return pg_ascii_tolower(c);
      97             : #ifdef HAVE_LOCALE_T
      98           0 :     else if (locale)
      99           0 :         return tolower_l(c, locale->info.lt);
     100             : #endif
     101             :     else
     102           0 :         return pg_tolower(c);
     103             : }
     104             : 
     105             : 
     106             : #define NextByte(p, plen)   ((p)++, (plen)--)
     107             : 
     108             : /* Set up to compile like_match.c for multibyte characters */
     109             : #define CHAREQ(p1, p2) wchareq((p1), (p2))
     110             : #define NextChar(p, plen) \
     111             :     do { int __l = pg_mblen(p); (p) +=__l; (plen) -=__l; } while (0)
     112             : #define CopyAdvChar(dst, src, srclen) \
     113             :     do { int __l = pg_mblen(src); \
     114             :          (srclen) -= __l; \
     115             :          while (__l-- > 0) \
     116             :              *(dst)++ = *(src)++; \
     117             :        } while (0)
     118             : 
     119             : #define MatchText   MB_MatchText
     120             : #define do_like_escape  MB_do_like_escape
     121             : 
     122             : #include "like_match.c"
     123             : 
     124             : /* Set up to compile like_match.c for single-byte characters */
     125             : #define CHAREQ(p1, p2) (*(p1) == *(p2))
     126             : #define NextChar(p, plen) NextByte((p), (plen))
     127             : #define CopyAdvChar(dst, src, srclen) (*(dst)++ = *(src)++, (srclen)--)
     128             : 
     129             : #define MatchText   SB_MatchText
     130             : #define do_like_escape  SB_do_like_escape
     131             : 
     132             : #include "like_match.c"
     133             : 
     134             : /* setup to compile like_match.c for single byte case insensitive matches */
     135             : #define MATCH_LOWER(t) SB_lower_char((unsigned char) (t), locale, locale_is_c)
     136             : #define NextChar(p, plen) NextByte((p), (plen))
     137             : #define MatchText SB_IMatchText
     138             : 
     139             : #include "like_match.c"
     140             : 
     141             : /* setup to compile like_match.c for UTF8 encoding, using fast NextChar */
     142             : 
     143             : #define NextChar(p, plen) \
     144             :     do { (p)++; (plen)--; } while ((plen) > 0 && (*(p) & 0xC0) == 0x80 )
     145             : #define MatchText   UTF8_MatchText
     146             : 
     147             : #include "like_match.c"
     148             : 
     149             : /* Generic for all cases not requiring inline case-folding */
     150             : static inline int
     151     1355252 : GenericMatchText(const char *s, int slen, const char *p, int plen, Oid collation)
     152             : {
     153     1355252 :     if (collation && !lc_ctype_is_c(collation) && collation != DEFAULT_COLLATION_OID)
     154             :     {
     155           0 :         pg_locale_t locale = pg_newlocale_from_collation(collation);
     156             : 
     157           0 :         if (locale && !locale->deterministic)
     158           0 :             ereport(ERROR,
     159             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     160             :                      errmsg("nondeterministic collations are not supported for LIKE")));
     161             :     }
     162             : 
     163     1355252 :     if (pg_database_encoding_max_length() == 1)
     164       38796 :         return SB_MatchText(s, slen, p, plen, 0, true);
     165     1316456 :     else if (GetDatabaseEncoding() == PG_UTF8)
     166     1316456 :         return UTF8_MatchText(s, slen, p, plen, 0, true);
     167             :     else
     168           0 :         return MB_MatchText(s, slen, p, plen, 0, true);
     169             : }
     170             : 
     171             : static inline int
     172        4896 : Generic_Text_IC_like(text *str, text *pat, Oid collation)
     173             : {
     174             :     char       *s,
     175             :                *p;
     176             :     int         slen,
     177             :                 plen;
     178        4896 :     pg_locale_t locale = 0;
     179        4896 :     bool        locale_is_c = false;
     180             : 
     181        4896 :     if (lc_ctype_is_c(collation))
     182        4784 :         locale_is_c = true;
     183         112 :     else if (collation != DEFAULT_COLLATION_OID)
     184             :     {
     185           0 :         if (!OidIsValid(collation))
     186             :         {
     187             :             /*
     188             :              * This typically means that the parser could not resolve a
     189             :              * conflict of implicit collations, so report it that way.
     190             :              */
     191           0 :             ereport(ERROR,
     192             :                     (errcode(ERRCODE_INDETERMINATE_COLLATION),
     193             :                      errmsg("could not determine which collation to use for ILIKE"),
     194             :                      errhint("Use the COLLATE clause to set the collation explicitly.")));
     195             :         }
     196           0 :         locale = pg_newlocale_from_collation(collation);
     197             : 
     198           0 :         if (locale && !locale->deterministic)
     199           0 :             ereport(ERROR,
     200             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     201             :                      errmsg("nondeterministic collations are not supported for ILIKE")));
     202             :     }
     203             : 
     204             :     /*
     205             :      * For efficiency reasons, in the single byte case we don't call lower()
     206             :      * on the pattern and text, but instead call SB_lower_char on each
     207             :      * character.  In the multi-byte case we don't have much choice :-(. Also,
     208             :      * ICU does not support single-character case folding, so we go the long
     209             :      * way.
     210             :      */
     211             : 
     212        4896 :     if (pg_database_encoding_max_length() > 1 || (locale && locale->provider == COLLPROVIDER_ICU))
     213             :     {
     214        4896 :         pat = DatumGetTextPP(DirectFunctionCall1Coll(lower, collation,
     215             :                                                      PointerGetDatum(pat)));
     216        4896 :         p = VARDATA_ANY(pat);
     217        4896 :         plen = VARSIZE_ANY_EXHDR(pat);
     218        4896 :         str = DatumGetTextPP(DirectFunctionCall1Coll(lower, collation,
     219             :                                                      PointerGetDatum(str)));
     220        4896 :         s = VARDATA_ANY(str);
     221        4896 :         slen = VARSIZE_ANY_EXHDR(str);
     222        4896 :         if (GetDatabaseEncoding() == PG_UTF8)
     223        4896 :             return UTF8_MatchText(s, slen, p, plen, 0, true);
     224             :         else
     225           0 :             return MB_MatchText(s, slen, p, plen, 0, true);
     226             :     }
     227             :     else
     228             :     {
     229           0 :         p = VARDATA_ANY(pat);
     230           0 :         plen = VARSIZE_ANY_EXHDR(pat);
     231           0 :         s = VARDATA_ANY(str);
     232           0 :         slen = VARSIZE_ANY_EXHDR(str);
     233           0 :         return SB_IMatchText(s, slen, p, plen, locale, locale_is_c);
     234             :     }
     235             : }
     236             : 
     237             : /*
     238             :  *  interface routines called by the function manager
     239             :  */
     240             : 
     241             : Datum
     242      105756 : namelike(PG_FUNCTION_ARGS)
     243             : {
     244      105756 :     Name        str = PG_GETARG_NAME(0);
     245      105756 :     text       *pat = PG_GETARG_TEXT_PP(1);
     246             :     bool        result;
     247             :     char       *s,
     248             :                *p;
     249             :     int         slen,
     250             :                 plen;
     251             : 
     252      105756 :     s = NameStr(*str);
     253      105756 :     slen = strlen(s);
     254      105756 :     p = VARDATA_ANY(pat);
     255      105756 :     plen = VARSIZE_ANY_EXHDR(pat);
     256             : 
     257      105756 :     result = (GenericMatchText(s, slen, p, plen, PG_GET_COLLATION()) == LIKE_TRUE);
     258             : 
     259      105756 :     PG_RETURN_BOOL(result);
     260             : }
     261             : 
     262             : Datum
     263        2512 : namenlike(PG_FUNCTION_ARGS)
     264             : {
     265        2512 :     Name        str = PG_GETARG_NAME(0);
     266        2512 :     text       *pat = PG_GETARG_TEXT_PP(1);
     267             :     bool        result;
     268             :     char       *s,
     269             :                *p;
     270             :     int         slen,
     271             :                 plen;
     272             : 
     273        2512 :     s = NameStr(*str);
     274        2512 :     slen = strlen(s);
     275        2512 :     p = VARDATA_ANY(pat);
     276        2512 :     plen = VARSIZE_ANY_EXHDR(pat);
     277             : 
     278        2512 :     result = (GenericMatchText(s, slen, p, plen, PG_GET_COLLATION()) != LIKE_TRUE);
     279             : 
     280        2512 :     PG_RETURN_BOOL(result);
     281             : }
     282             : 
     283             : Datum
     284     1125844 : textlike(PG_FUNCTION_ARGS)
     285             : {
     286     1125844 :     text       *str = PG_GETARG_TEXT_PP(0);
     287     1125844 :     text       *pat = PG_GETARG_TEXT_PP(1);
     288             :     bool        result;
     289             :     char       *s,
     290             :                *p;
     291             :     int         slen,
     292             :                 plen;
     293             : 
     294     1125844 :     s = VARDATA_ANY(str);
     295     1125844 :     slen = VARSIZE_ANY_EXHDR(str);
     296     1125844 :     p = VARDATA_ANY(pat);
     297     1125844 :     plen = VARSIZE_ANY_EXHDR(pat);
     298             : 
     299     1125844 :     result = (GenericMatchText(s, slen, p, plen, PG_GET_COLLATION()) == LIKE_TRUE);
     300             : 
     301     1125844 :     PG_RETURN_BOOL(result);
     302             : }
     303             : 
     304             : Datum
     305      121140 : textnlike(PG_FUNCTION_ARGS)
     306             : {
     307      121140 :     text       *str = PG_GETARG_TEXT_PP(0);
     308      121140 :     text       *pat = PG_GETARG_TEXT_PP(1);
     309             :     bool        result;
     310             :     char       *s,
     311             :                *p;
     312             :     int         slen,
     313             :                 plen;
     314             : 
     315      121140 :     s = VARDATA_ANY(str);
     316      121140 :     slen = VARSIZE_ANY_EXHDR(str);
     317      121140 :     p = VARDATA_ANY(pat);
     318      121140 :     plen = VARSIZE_ANY_EXHDR(pat);
     319             : 
     320      121140 :     result = (GenericMatchText(s, slen, p, plen, PG_GET_COLLATION()) != LIKE_TRUE);
     321             : 
     322      121140 :     PG_RETURN_BOOL(result);
     323             : }
     324             : 
     325             : Datum
     326           0 : bytealike(PG_FUNCTION_ARGS)
     327             : {
     328           0 :     bytea      *str = PG_GETARG_BYTEA_PP(0);
     329           0 :     bytea      *pat = PG_GETARG_BYTEA_PP(1);
     330             :     bool        result;
     331             :     char       *s,
     332             :                *p;
     333             :     int         slen,
     334             :                 plen;
     335             : 
     336           0 :     s = VARDATA_ANY(str);
     337           0 :     slen = VARSIZE_ANY_EXHDR(str);
     338           0 :     p = VARDATA_ANY(pat);
     339           0 :     plen = VARSIZE_ANY_EXHDR(pat);
     340             : 
     341           0 :     result = (SB_MatchText(s, slen, p, plen, 0, true) == LIKE_TRUE);
     342             : 
     343           0 :     PG_RETURN_BOOL(result);
     344             : }
     345             : 
     346             : Datum
     347           0 : byteanlike(PG_FUNCTION_ARGS)
     348             : {
     349           0 :     bytea      *str = PG_GETARG_BYTEA_PP(0);
     350           0 :     bytea      *pat = PG_GETARG_BYTEA_PP(1);
     351             :     bool        result;
     352             :     char       *s,
     353             :                *p;
     354             :     int         slen,
     355             :                 plen;
     356             : 
     357           0 :     s = VARDATA_ANY(str);
     358           0 :     slen = VARSIZE_ANY_EXHDR(str);
     359           0 :     p = VARDATA_ANY(pat);
     360           0 :     plen = VARSIZE_ANY_EXHDR(pat);
     361             : 
     362           0 :     result = (SB_MatchText(s, slen, p, plen, 0, true) != LIKE_TRUE);
     363             : 
     364           0 :     PG_RETURN_BOOL(result);
     365             : }
     366             : 
     367             : /*
     368             :  * Case-insensitive versions
     369             :  */
     370             : 
     371             : Datum
     372        4776 : nameiclike(PG_FUNCTION_ARGS)
     373             : {
     374        4776 :     Name        str = PG_GETARG_NAME(0);
     375        4776 :     text       *pat = PG_GETARG_TEXT_PP(1);
     376             :     bool        result;
     377             :     text       *strtext;
     378             : 
     379        4776 :     strtext = DatumGetTextPP(DirectFunctionCall1(name_text,
     380             :                                                  NameGetDatum(str)));
     381        4776 :     result = (Generic_Text_IC_like(strtext, pat, PG_GET_COLLATION()) == LIKE_TRUE);
     382             : 
     383        4776 :     PG_RETURN_BOOL(result);
     384             : }
     385             : 
     386             : Datum
     387           0 : nameicnlike(PG_FUNCTION_ARGS)
     388             : {
     389           0 :     Name        str = PG_GETARG_NAME(0);
     390           0 :     text       *pat = PG_GETARG_TEXT_PP(1);
     391             :     bool        result;
     392             :     text       *strtext;
     393             : 
     394           0 :     strtext = DatumGetTextPP(DirectFunctionCall1(name_text,
     395             :                                                  NameGetDatum(str)));
     396           0 :     result = (Generic_Text_IC_like(strtext, pat, PG_GET_COLLATION()) != LIKE_TRUE);
     397             : 
     398           0 :     PG_RETURN_BOOL(result);
     399             : }
     400             : 
     401             : Datum
     402          72 : texticlike(PG_FUNCTION_ARGS)
     403             : {
     404          72 :     text       *str = PG_GETARG_TEXT_PP(0);
     405          72 :     text       *pat = PG_GETARG_TEXT_PP(1);
     406             :     bool        result;
     407             : 
     408          72 :     result = (Generic_Text_IC_like(str, pat, PG_GET_COLLATION()) == LIKE_TRUE);
     409             : 
     410          72 :     PG_RETURN_BOOL(result);
     411             : }
     412             : 
     413             : Datum
     414          48 : texticnlike(PG_FUNCTION_ARGS)
     415             : {
     416          48 :     text       *str = PG_GETARG_TEXT_PP(0);
     417          48 :     text       *pat = PG_GETARG_TEXT_PP(1);
     418             :     bool        result;
     419             : 
     420          48 :     result = (Generic_Text_IC_like(str, pat, PG_GET_COLLATION()) != LIKE_TRUE);
     421             : 
     422          48 :     PG_RETURN_BOOL(result);
     423             : }
     424             : 
     425             : /*
     426             :  * like_escape() --- given a pattern and an ESCAPE string,
     427             :  * convert the pattern to use Postgres' standard backslash escape convention.
     428             :  */
     429             : Datum
     430         152 : like_escape(PG_FUNCTION_ARGS)
     431             : {
     432         152 :     text       *pat = PG_GETARG_TEXT_PP(0);
     433         152 :     text       *esc = PG_GETARG_TEXT_PP(1);
     434             :     text       *result;
     435             : 
     436         152 :     if (pg_database_encoding_max_length() == 1)
     437           0 :         result = SB_do_like_escape(pat, esc);
     438             :     else
     439         152 :         result = MB_do_like_escape(pat, esc);
     440             : 
     441         152 :     PG_RETURN_TEXT_P(result);
     442             : }
     443             : 
     444             : /*
     445             :  * like_escape_bytea() --- given a pattern and an ESCAPE string,
     446             :  * convert the pattern to use Postgres' standard backslash escape convention.
     447             :  */
     448             : Datum
     449           0 : like_escape_bytea(PG_FUNCTION_ARGS)
     450             : {
     451           0 :     bytea      *pat = PG_GETARG_BYTEA_PP(0);
     452           0 :     bytea      *esc = PG_GETARG_BYTEA_PP(1);
     453           0 :     bytea      *result = SB_do_like_escape((text *) pat, (text *) esc);
     454             : 
     455           0 :     PG_RETURN_BYTEA_P((bytea *) result);
     456             : }

Generated by: LCOV version 1.13