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