1 /*-------------------------------------------------------------------------
2 *
3 * regexp.c
4 * Postgres' interface to the regular expression package.
5 *
6 * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/utils/adt/regexp.c
12 *
13 * Alistair Crooks added the code for the regex caching
14 * agc - cached the regular expressions used - there's a good chance
15 * that we'll get a hit, so this saves a compile step for every
16 * attempted match. I haven't actually measured the speed improvement,
17 * but it `looks' a lot quicker visually when watching regression
18 * test output.
19 *
20 * agc - incorporated Keith Bostic's Berkeley regex code into
21 * the tree for all ports. To distinguish this regex code from any that
22 * is existent on a platform, I've prepended the string "pg_" to
23 * the functions regcomp, regerror, regexec and regfree.
24 * Fixed a bug that was originally a typo by me, where `i' was used
25 * instead of `oldest' when compiling regular expressions - benign
26 * results mostly, although occasionally it bit you...
27 *
28 *-------------------------------------------------------------------------
29 */
30 #include "postgres.h"
31
32 #include "catalog/pg_type.h"
33 #include "funcapi.h"
34 #include "miscadmin.h"
35 #include "regex/regex.h"
36 #include "utils/array.h"
37 #include "utils/builtins.h"
38 #include "utils/memutils.h"
39 #include "utils/varlena.h"
40
41 #define PG_GETARG_TEXT_PP_IF_EXISTS(_n) \
42 (PG_NARGS() > (_n) ? PG_GETARG_TEXT_PP(_n) : NULL)
43
44
45 /* all the options of interest for regex functions */
46 typedef struct pg_re_flags
47 {
48 int cflags; /* compile flags for Spencer's regex code */
49 bool glob; /* do it globally (for each occurrence) */
50 } pg_re_flags;
51
52 /* cross-call state for regexp_match and regexp_split functions */
53 typedef struct regexp_matches_ctx
54 {
55 text *orig_str; /* data string in original TEXT form */
56 int nmatches; /* number of places where pattern matched */
57 int npatterns; /* number of capturing subpatterns */
58 /* We store start char index and end+1 char index for each match */
59 /* so the number of entries in match_locs is nmatches * npatterns * 2 */
60 int *match_locs; /* 0-based character indexes */
61 int next_match; /* 0-based index of next match to process */
62 /* workspace for build_regexp_match_result() */
63 Datum *elems; /* has npatterns elements */
64 bool *nulls; /* has npatterns elements */
65 pg_wchar *wide_str; /* wide-char version of original string */
66 char *conv_buf; /* conversion buffer */
67 int conv_bufsiz; /* size thereof */
68 } regexp_matches_ctx;
69
70 /*
71 * We cache precompiled regular expressions using a "self organizing list"
72 * structure, in which recently-used items tend to be near the front.
73 * Whenever we use an entry, it's moved up to the front of the list.
74 * Over time, an item's average position corresponds to its frequency of use.
75 *
76 * When we first create an entry, it's inserted at the front of
77 * the array, dropping the entry at the end of the array if necessary to
78 * make room. (This might seem to be weighting the new entry too heavily,
79 * but if we insert new entries further back, we'll be unable to adjust to
80 * a sudden shift in the query mix where we are presented with MAX_CACHED_RES
81 * never-before-seen items used circularly. We ought to be able to handle
82 * that case, so we have to insert at the front.)
83 *
84 * Knuth mentions a variant strategy in which a used item is moved up just
85 * one place in the list. Although he says this uses fewer comparisons on
86 * average, it seems not to adapt very well to the situation where you have
87 * both some reusable patterns and a steady stream of non-reusable patterns.
88 * A reusable pattern that isn't used at least as often as non-reusable
89 * patterns are seen will "fail to keep up" and will drop off the end of the
90 * cache. With move-to-front, a reusable pattern is guaranteed to stay in
91 * the cache as long as it's used at least once in every MAX_CACHED_RES uses.
92 */
93
94 /* this is the maximum number of cached regular expressions */
95 #ifndef MAX_CACHED_RES
96 #define MAX_CACHED_RES 32
97 #endif
98
99 /* this structure describes one cached regular expression */
100 typedef struct cached_re_str
101 {
102 char *cre_pat; /* original RE (not null terminated!) */
103 int cre_pat_len; /* length of original RE, in bytes */
104 int cre_flags; /* compile flags: extended,icase etc */
105 Oid cre_collation; /* collation to use */
106 regex_t cre_re; /* the compiled regular expression */
107 } cached_re_str;
108
109 static int num_res = 0; /* # of cached re's */
110 static cached_re_str re_array[MAX_CACHED_RES]; /* cached re's */
111
112
113 /* Local functions */
114 static regexp_matches_ctx *setup_regexp_matches(text *orig_str, text *pattern,
115 pg_re_flags *flags,
116 Oid collation,
117 bool use_subpatterns,
118 bool ignore_degenerate,
119 bool fetching_unmatched);
120 static ArrayType *build_regexp_match_result(regexp_matches_ctx *matchctx);
121 static Datum build_regexp_split_result(regexp_matches_ctx *splitctx);
122
123
124 /*
125 * RE_compile_and_cache - compile a RE, caching if possible
126 *
127 * Returns regex_t *
128 *
129 * text_re --- the pattern, expressed as a TEXT object
130 * cflags --- compile options for the pattern
131 * collation --- collation to use for LC_CTYPE-dependent behavior
132 *
133 * Pattern is given in the database encoding. We internally convert to
134 * an array of pg_wchar, which is what Spencer's regex package wants.
135 */
136 static regex_t *
RE_compile_and_cache(text * text_re,int cflags,Oid collation)137 RE_compile_and_cache(text *text_re, int cflags, Oid collation)
138 {
139 int text_re_len = VARSIZE_ANY_EXHDR(text_re);
140 char *text_re_val = VARDATA_ANY(text_re);
141 pg_wchar *pattern;
142 int pattern_len;
143 int i;
144 int regcomp_result;
145 cached_re_str re_temp;
146 char errMsg[100];
147
148 /*
149 * Look for a match among previously compiled REs. Since the data
150 * structure is self-organizing with most-used entries at the front, our
151 * search strategy can just be to scan from the front.
152 */
153 for (i = 0; i < num_res; i++)
154 {
155 if (re_array[i].cre_pat_len == text_re_len &&
156 re_array[i].cre_flags == cflags &&
157 re_array[i].cre_collation == collation &&
158 memcmp(re_array[i].cre_pat, text_re_val, text_re_len) == 0)
159 {
160 /*
161 * Found a match; move it to front if not there already.
162 */
163 if (i > 0)
164 {
165 re_temp = re_array[i];
166 memmove(&re_array[1], &re_array[0], i * sizeof(cached_re_str));
167 re_array[0] = re_temp;
168 }
169
170 return &re_array[0].cre_re;
171 }
172 }
173
174 /*
175 * Couldn't find it, so try to compile the new RE. To avoid leaking
176 * resources on failure, we build into the re_temp local.
177 */
178
179 /* Convert pattern string to wide characters */
180 pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar));
181 pattern_len = pg_mb2wchar_with_len(text_re_val,
182 pattern,
183 text_re_len);
184
185 regcomp_result = pg_regcomp(&re_temp.cre_re,
186 pattern,
187 pattern_len,
188 cflags,
189 collation);
190
191 pfree(pattern);
192
193 if (regcomp_result != REG_OKAY)
194 {
195 /* re didn't compile (no need for pg_regfree, if so) */
196
197 /*
198 * Here and in other places in this file, do CHECK_FOR_INTERRUPTS
199 * before reporting a regex error. This is so that if the regex
200 * library aborts and returns REG_CANCEL, we don't print an error
201 * message that implies the regex was invalid.
202 */
203 CHECK_FOR_INTERRUPTS();
204
205 pg_regerror(regcomp_result, &re_temp.cre_re, errMsg, sizeof(errMsg));
206 ereport(ERROR,
207 (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
208 errmsg("invalid regular expression: %s", errMsg)));
209 }
210
211 /*
212 * We use malloc/free for the cre_pat field because the storage has to
213 * persist across transactions, and because we want to get control back on
214 * out-of-memory. The Max() is because some malloc implementations return
215 * NULL for malloc(0).
216 */
217 re_temp.cre_pat = malloc(Max(text_re_len, 1));
218 if (re_temp.cre_pat == NULL)
219 {
220 pg_regfree(&re_temp.cre_re);
221 ereport(ERROR,
222 (errcode(ERRCODE_OUT_OF_MEMORY),
223 errmsg("out of memory")));
224 }
225 memcpy(re_temp.cre_pat, text_re_val, text_re_len);
226 re_temp.cre_pat_len = text_re_len;
227 re_temp.cre_flags = cflags;
228 re_temp.cre_collation = collation;
229
230 /*
231 * Okay, we have a valid new item in re_temp; insert it into the storage
232 * array. Discard last entry if needed.
233 */
234 if (num_res >= MAX_CACHED_RES)
235 {
236 --num_res;
237 Assert(num_res < MAX_CACHED_RES);
238 pg_regfree(&re_array[num_res].cre_re);
239 free(re_array[num_res].cre_pat);
240 }
241
242 if (num_res > 0)
243 memmove(&re_array[1], &re_array[0], num_res * sizeof(cached_re_str));
244
245 re_array[0] = re_temp;
246 num_res++;
247
248 return &re_array[0].cre_re;
249 }
250
251 /*
252 * RE_wchar_execute - execute a RE on pg_wchar data
253 *
254 * Returns true on match, false on no match
255 *
256 * re --- the compiled pattern as returned by RE_compile_and_cache
257 * data --- the data to match against (need not be null-terminated)
258 * data_len --- the length of the data string
259 * start_search -- the offset in the data to start searching
260 * nmatch, pmatch --- optional return area for match details
261 *
262 * Data is given as array of pg_wchar which is what Spencer's regex package
263 * wants.
264 */
265 static bool
RE_wchar_execute(regex_t * re,pg_wchar * data,int data_len,int start_search,int nmatch,regmatch_t * pmatch)266 RE_wchar_execute(regex_t *re, pg_wchar *data, int data_len,
267 int start_search, int nmatch, regmatch_t *pmatch)
268 {
269 int regexec_result;
270 char errMsg[100];
271
272 /* Perform RE match and return result */
273 regexec_result = pg_regexec(re,
274 data,
275 data_len,
276 start_search,
277 NULL, /* no details */
278 nmatch,
279 pmatch,
280 0);
281
282 if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
283 {
284 /* re failed??? */
285 CHECK_FOR_INTERRUPTS();
286 pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
287 ereport(ERROR,
288 (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
289 errmsg("regular expression failed: %s", errMsg)));
290 }
291
292 return (regexec_result == REG_OKAY);
293 }
294
295 /*
296 * RE_execute - execute a RE
297 *
298 * Returns true on match, false on no match
299 *
300 * re --- the compiled pattern as returned by RE_compile_and_cache
301 * dat --- the data to match against (need not be null-terminated)
302 * dat_len --- the length of the data string
303 * nmatch, pmatch --- optional return area for match details
304 *
305 * Data is given in the database encoding. We internally
306 * convert to array of pg_wchar which is what Spencer's regex package wants.
307 */
308 static bool
RE_execute(regex_t * re,char * dat,int dat_len,int nmatch,regmatch_t * pmatch)309 RE_execute(regex_t *re, char *dat, int dat_len,
310 int nmatch, regmatch_t *pmatch)
311 {
312 pg_wchar *data;
313 int data_len;
314 bool match;
315
316 /* Convert data string to wide characters */
317 data = (pg_wchar *) palloc((dat_len + 1) * sizeof(pg_wchar));
318 data_len = pg_mb2wchar_with_len(dat, data, dat_len);
319
320 /* Perform RE match and return result */
321 match = RE_wchar_execute(re, data, data_len, 0, nmatch, pmatch);
322
323 pfree(data);
324 return match;
325 }
326
327 /*
328 * RE_compile_and_execute - compile and execute a RE
329 *
330 * Returns true on match, false on no match
331 *
332 * text_re --- the pattern, expressed as a TEXT object
333 * dat --- the data to match against (need not be null-terminated)
334 * dat_len --- the length of the data string
335 * cflags --- compile options for the pattern
336 * collation --- collation to use for LC_CTYPE-dependent behavior
337 * nmatch, pmatch --- optional return area for match details
338 *
339 * Both pattern and data are given in the database encoding. We internally
340 * convert to array of pg_wchar which is what Spencer's regex package wants.
341 */
342 static bool
RE_compile_and_execute(text * text_re,char * dat,int dat_len,int cflags,Oid collation,int nmatch,regmatch_t * pmatch)343 RE_compile_and_execute(text *text_re, char *dat, int dat_len,
344 int cflags, Oid collation,
345 int nmatch, regmatch_t *pmatch)
346 {
347 regex_t *re;
348
349 /* Compile RE */
350 re = RE_compile_and_cache(text_re, cflags, collation);
351
352 return RE_execute(re, dat, dat_len, nmatch, pmatch);
353 }
354
355
356 /*
357 * parse_re_flags - parse the options argument of regexp_match and friends
358 *
359 * flags --- output argument, filled with desired options
360 * opts --- TEXT object, or NULL for defaults
361 *
362 * This accepts all the options allowed by any of the callers; callers that
363 * don't want some have to reject them after the fact.
364 */
365 static void
parse_re_flags(pg_re_flags * flags,text * opts)366 parse_re_flags(pg_re_flags *flags, text *opts)
367 {
368 /* regex flavor is always folded into the compile flags */
369 flags->cflags = REG_ADVANCED;
370 flags->glob = false;
371
372 if (opts)
373 {
374 char *opt_p = VARDATA_ANY(opts);
375 int opt_len = VARSIZE_ANY_EXHDR(opts);
376 int i;
377
378 for (i = 0; i < opt_len; i++)
379 {
380 switch (opt_p[i])
381 {
382 case 'g':
383 flags->glob = true;
384 break;
385 case 'b': /* BREs (but why???) */
386 flags->cflags &= ~(REG_ADVANCED | REG_EXTENDED | REG_QUOTE);
387 break;
388 case 'c': /* case sensitive */
389 flags->cflags &= ~REG_ICASE;
390 break;
391 case 'e': /* plain EREs */
392 flags->cflags |= REG_EXTENDED;
393 flags->cflags &= ~(REG_ADVANCED | REG_QUOTE);
394 break;
395 case 'i': /* case insensitive */
396 flags->cflags |= REG_ICASE;
397 break;
398 case 'm': /* Perloid synonym for n */
399 case 'n': /* \n affects ^ $ . [^ */
400 flags->cflags |= REG_NEWLINE;
401 break;
402 case 'p': /* ~Perl, \n affects . [^ */
403 flags->cflags |= REG_NLSTOP;
404 flags->cflags &= ~REG_NLANCH;
405 break;
406 case 'q': /* literal string */
407 flags->cflags |= REG_QUOTE;
408 flags->cflags &= ~(REG_ADVANCED | REG_EXTENDED);
409 break;
410 case 's': /* single line, \n ordinary */
411 flags->cflags &= ~REG_NEWLINE;
412 break;
413 case 't': /* tight syntax */
414 flags->cflags &= ~REG_EXPANDED;
415 break;
416 case 'w': /* weird, \n affects ^ $ only */
417 flags->cflags &= ~REG_NLSTOP;
418 flags->cflags |= REG_NLANCH;
419 break;
420 case 'x': /* expanded syntax */
421 flags->cflags |= REG_EXPANDED;
422 break;
423 default:
424 ereport(ERROR,
425 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
426 errmsg("invalid regexp option: \"%c\"",
427 opt_p[i])));
428 break;
429 }
430 }
431 }
432 }
433
434
435 /*
436 * interface routines called by the function manager
437 */
438
439 Datum
nameregexeq(PG_FUNCTION_ARGS)440 nameregexeq(PG_FUNCTION_ARGS)
441 {
442 Name n = PG_GETARG_NAME(0);
443 text *p = PG_GETARG_TEXT_PP(1);
444
445 PG_RETURN_BOOL(RE_compile_and_execute(p,
446 NameStr(*n),
447 strlen(NameStr(*n)),
448 REG_ADVANCED,
449 PG_GET_COLLATION(),
450 0, NULL));
451 }
452
453 Datum
nameregexne(PG_FUNCTION_ARGS)454 nameregexne(PG_FUNCTION_ARGS)
455 {
456 Name n = PG_GETARG_NAME(0);
457 text *p = PG_GETARG_TEXT_PP(1);
458
459 PG_RETURN_BOOL(!RE_compile_and_execute(p,
460 NameStr(*n),
461 strlen(NameStr(*n)),
462 REG_ADVANCED,
463 PG_GET_COLLATION(),
464 0, NULL));
465 }
466
467 Datum
textregexeq(PG_FUNCTION_ARGS)468 textregexeq(PG_FUNCTION_ARGS)
469 {
470 text *s = PG_GETARG_TEXT_PP(0);
471 text *p = PG_GETARG_TEXT_PP(1);
472
473 PG_RETURN_BOOL(RE_compile_and_execute(p,
474 VARDATA_ANY(s),
475 VARSIZE_ANY_EXHDR(s),
476 REG_ADVANCED,
477 PG_GET_COLLATION(),
478 0, NULL));
479 }
480
481 Datum
textregexne(PG_FUNCTION_ARGS)482 textregexne(PG_FUNCTION_ARGS)
483 {
484 text *s = PG_GETARG_TEXT_PP(0);
485 text *p = PG_GETARG_TEXT_PP(1);
486
487 PG_RETURN_BOOL(!RE_compile_and_execute(p,
488 VARDATA_ANY(s),
489 VARSIZE_ANY_EXHDR(s),
490 REG_ADVANCED,
491 PG_GET_COLLATION(),
492 0, NULL));
493 }
494
495
496 /*
497 * routines that use the regexp stuff, but ignore the case.
498 * for this, we use the REG_ICASE flag to pg_regcomp
499 */
500
501
502 Datum
nameicregexeq(PG_FUNCTION_ARGS)503 nameicregexeq(PG_FUNCTION_ARGS)
504 {
505 Name n = PG_GETARG_NAME(0);
506 text *p = PG_GETARG_TEXT_PP(1);
507
508 PG_RETURN_BOOL(RE_compile_and_execute(p,
509 NameStr(*n),
510 strlen(NameStr(*n)),
511 REG_ADVANCED | REG_ICASE,
512 PG_GET_COLLATION(),
513 0, NULL));
514 }
515
516 Datum
nameicregexne(PG_FUNCTION_ARGS)517 nameicregexne(PG_FUNCTION_ARGS)
518 {
519 Name n = PG_GETARG_NAME(0);
520 text *p = PG_GETARG_TEXT_PP(1);
521
522 PG_RETURN_BOOL(!RE_compile_and_execute(p,
523 NameStr(*n),
524 strlen(NameStr(*n)),
525 REG_ADVANCED | REG_ICASE,
526 PG_GET_COLLATION(),
527 0, NULL));
528 }
529
530 Datum
texticregexeq(PG_FUNCTION_ARGS)531 texticregexeq(PG_FUNCTION_ARGS)
532 {
533 text *s = PG_GETARG_TEXT_PP(0);
534 text *p = PG_GETARG_TEXT_PP(1);
535
536 PG_RETURN_BOOL(RE_compile_and_execute(p,
537 VARDATA_ANY(s),
538 VARSIZE_ANY_EXHDR(s),
539 REG_ADVANCED | REG_ICASE,
540 PG_GET_COLLATION(),
541 0, NULL));
542 }
543
544 Datum
texticregexne(PG_FUNCTION_ARGS)545 texticregexne(PG_FUNCTION_ARGS)
546 {
547 text *s = PG_GETARG_TEXT_PP(0);
548 text *p = PG_GETARG_TEXT_PP(1);
549
550 PG_RETURN_BOOL(!RE_compile_and_execute(p,
551 VARDATA_ANY(s),
552 VARSIZE_ANY_EXHDR(s),
553 REG_ADVANCED | REG_ICASE,
554 PG_GET_COLLATION(),
555 0, NULL));
556 }
557
558
559 /*
560 * textregexsubstr()
561 * Return a substring matched by a regular expression.
562 */
563 Datum
textregexsubstr(PG_FUNCTION_ARGS)564 textregexsubstr(PG_FUNCTION_ARGS)
565 {
566 text *s = PG_GETARG_TEXT_PP(0);
567 text *p = PG_GETARG_TEXT_PP(1);
568 regex_t *re;
569 regmatch_t pmatch[2];
570 int so,
571 eo;
572
573 /* Compile RE */
574 re = RE_compile_and_cache(p, REG_ADVANCED, PG_GET_COLLATION());
575
576 /*
577 * We pass two regmatch_t structs to get info about the overall match and
578 * the match for the first parenthesized subexpression (if any). If there
579 * is a parenthesized subexpression, we return what it matched; else
580 * return what the whole regexp matched.
581 */
582 if (!RE_execute(re,
583 VARDATA_ANY(s), VARSIZE_ANY_EXHDR(s),
584 2, pmatch))
585 PG_RETURN_NULL(); /* definitely no match */
586
587 if (re->re_nsub > 0)
588 {
589 /* has parenthesized subexpressions, use the first one */
590 so = pmatch[1].rm_so;
591 eo = pmatch[1].rm_eo;
592 }
593 else
594 {
595 /* no parenthesized subexpression, use whole match */
596 so = pmatch[0].rm_so;
597 eo = pmatch[0].rm_eo;
598 }
599
600 /*
601 * It is possible to have a match to the whole pattern but no match for a
602 * subexpression; for example 'foo(bar)?' is considered to match 'foo' but
603 * there is no subexpression match. So this extra test for match failure
604 * is not redundant.
605 */
606 if (so < 0 || eo < 0)
607 PG_RETURN_NULL();
608
609 return DirectFunctionCall3(text_substr,
610 PointerGetDatum(s),
611 Int32GetDatum(so + 1),
612 Int32GetDatum(eo - so));
613 }
614
615 /*
616 * textregexreplace_noopt()
617 * Return a string matched by a regular expression, with replacement.
618 *
619 * This version doesn't have an option argument: we default to case
620 * sensitive match, replace the first instance only.
621 */
622 Datum
textregexreplace_noopt(PG_FUNCTION_ARGS)623 textregexreplace_noopt(PG_FUNCTION_ARGS)
624 {
625 text *s = PG_GETARG_TEXT_PP(0);
626 text *p = PG_GETARG_TEXT_PP(1);
627 text *r = PG_GETARG_TEXT_PP(2);
628 regex_t *re;
629
630 re = RE_compile_and_cache(p, REG_ADVANCED, PG_GET_COLLATION());
631
632 PG_RETURN_TEXT_P(replace_text_regexp(s, (void *) re, r, false));
633 }
634
635 /*
636 * textregexreplace()
637 * Return a string matched by a regular expression, with replacement.
638 */
639 Datum
textregexreplace(PG_FUNCTION_ARGS)640 textregexreplace(PG_FUNCTION_ARGS)
641 {
642 text *s = PG_GETARG_TEXT_PP(0);
643 text *p = PG_GETARG_TEXT_PP(1);
644 text *r = PG_GETARG_TEXT_PP(2);
645 text *opt = PG_GETARG_TEXT_PP(3);
646 regex_t *re;
647 pg_re_flags flags;
648
649 parse_re_flags(&flags, opt);
650
651 re = RE_compile_and_cache(p, flags.cflags, PG_GET_COLLATION());
652
653 PG_RETURN_TEXT_P(replace_text_regexp(s, (void *) re, r, flags.glob));
654 }
655
656 /*
657 * similar_escape()
658 * Convert a SQL:2008 regexp pattern to POSIX style, so it can be used by
659 * our regexp engine.
660 */
661 Datum
similar_escape(PG_FUNCTION_ARGS)662 similar_escape(PG_FUNCTION_ARGS)
663 {
664 text *pat_text;
665 text *esc_text;
666 text *result;
667 char *p,
668 *e,
669 *r;
670 int plen,
671 elen;
672 bool afterescape = false;
673 bool incharclass = false;
674 int nquotes = 0;
675
676 /* This function is not strict, so must test explicitly */
677 if (PG_ARGISNULL(0))
678 PG_RETURN_NULL();
679 pat_text = PG_GETARG_TEXT_PP(0);
680 p = VARDATA_ANY(pat_text);
681 plen = VARSIZE_ANY_EXHDR(pat_text);
682 if (PG_ARGISNULL(1))
683 {
684 /* No ESCAPE clause provided; default to backslash as escape */
685 e = "\\";
686 elen = 1;
687 }
688 else
689 {
690 esc_text = PG_GETARG_TEXT_PP(1);
691 e = VARDATA_ANY(esc_text);
692 elen = VARSIZE_ANY_EXHDR(esc_text);
693 if (elen == 0)
694 e = NULL; /* no escape character */
695 else
696 {
697 int escape_mblen = pg_mbstrlen_with_len(e, elen);
698
699 if (escape_mblen > 1)
700 ereport(ERROR,
701 (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
702 errmsg("invalid escape string"),
703 errhint("Escape string must be empty or one character.")));
704 }
705 }
706
707 /*----------
708 * We surround the transformed input string with
709 * ^(?: ... )$
710 * which requires some explanation. We need "^" and "$" to force
711 * the pattern to match the entire input string as per SQL99 spec.
712 * The "(?:" and ")" are a non-capturing set of parens; we have to have
713 * parens in case the string contains "|", else the "^" and "$" will
714 * be bound into the first and last alternatives which is not what we
715 * want, and the parens must be non capturing because we don't want them
716 * to count when selecting output for SUBSTRING.
717 *----------
718 */
719
720 /*
721 * We need room for the prefix/postfix plus as many as 3 output bytes per
722 * input byte; since the input is at most 1GB this can't overflow
723 */
724 result = (text *) palloc(VARHDRSZ + 6 + 3 * plen);
725 r = VARDATA(result);
726
727 *r++ = '^';
728 *r++ = '(';
729 *r++ = '?';
730 *r++ = ':';
731
732 while (plen > 0)
733 {
734 char pchar = *p;
735
736 /*
737 * If both the escape character and the current character from the
738 * pattern are multi-byte, we need to take the slow path.
739 *
740 * But if one of them is single-byte, we can process the pattern one
741 * byte at a time, ignoring multi-byte characters. (This works
742 * because all server-encodings have the property that a valid
743 * multi-byte character representation cannot contain the
744 * representation of a valid single-byte character.)
745 */
746
747 if (elen > 1)
748 {
749 int mblen = pg_mblen(p);
750
751 if (mblen > 1)
752 {
753 /* slow, multi-byte path */
754 if (afterescape)
755 {
756 *r++ = '\\';
757 memcpy(r, p, mblen);
758 r += mblen;
759 afterescape = false;
760 }
761 else if (e && elen == mblen && memcmp(e, p, mblen) == 0)
762 {
763 /* SQL99 escape character; do not send to output */
764 afterescape = true;
765 }
766 else
767 {
768 /*
769 * We know it's a multi-byte character, so we don't need
770 * to do all the comparisons to single-byte characters
771 * that we do below.
772 */
773 memcpy(r, p, mblen);
774 r += mblen;
775 }
776
777 p += mblen;
778 plen -= mblen;
779
780 continue;
781 }
782 }
783
784 /* fast path */
785 if (afterescape)
786 {
787 if (pchar == '"' && !incharclass) /* for SUBSTRING patterns */
788 *r++ = ((nquotes++ % 2) == 0) ? '(' : ')';
789 else
790 {
791 *r++ = '\\';
792 *r++ = pchar;
793 }
794 afterescape = false;
795 }
796 else if (e && pchar == *e)
797 {
798 /* SQL99 escape character; do not send to output */
799 afterescape = true;
800 }
801 else if (incharclass)
802 {
803 if (pchar == '\\')
804 *r++ = '\\';
805 *r++ = pchar;
806 if (pchar == ']')
807 incharclass = false;
808 }
809 else if (pchar == '[')
810 {
811 *r++ = pchar;
812 incharclass = true;
813 }
814 else if (pchar == '%')
815 {
816 *r++ = '.';
817 *r++ = '*';
818 }
819 else if (pchar == '_')
820 *r++ = '.';
821 else if (pchar == '(')
822 {
823 /* convert to non-capturing parenthesis */
824 *r++ = '(';
825 *r++ = '?';
826 *r++ = ':';
827 }
828 else if (pchar == '\\' || pchar == '.' ||
829 pchar == '^' || pchar == '$')
830 {
831 *r++ = '\\';
832 *r++ = pchar;
833 }
834 else
835 *r++ = pchar;
836 p++, plen--;
837 }
838
839 *r++ = ')';
840 *r++ = '$';
841
842 SET_VARSIZE(result, r - ((char *) result));
843
844 PG_RETURN_TEXT_P(result);
845 }
846
847 /*
848 * regexp_match()
849 * Return the first substring(s) matching a pattern within a string.
850 */
851 Datum
regexp_match(PG_FUNCTION_ARGS)852 regexp_match(PG_FUNCTION_ARGS)
853 {
854 text *orig_str = PG_GETARG_TEXT_PP(0);
855 text *pattern = PG_GETARG_TEXT_PP(1);
856 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
857 pg_re_flags re_flags;
858 regexp_matches_ctx *matchctx;
859
860 /* Determine options */
861 parse_re_flags(&re_flags, flags);
862 /* User mustn't specify 'g' */
863 if (re_flags.glob)
864 ereport(ERROR,
865 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
866 errmsg("regexp_match does not support the global option"),
867 errhint("Use the regexp_matches function instead.")));
868
869 matchctx = setup_regexp_matches(orig_str, pattern, &re_flags,
870 PG_GET_COLLATION(), true, false, false);
871
872 if (matchctx->nmatches == 0)
873 PG_RETURN_NULL();
874
875 Assert(matchctx->nmatches == 1);
876
877 /* Create workspace that build_regexp_match_result needs */
878 matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
879 matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
880
881 PG_RETURN_DATUM(PointerGetDatum(build_regexp_match_result(matchctx)));
882 }
883
884 /* This is separate to keep the opr_sanity regression test from complaining */
885 Datum
regexp_match_no_flags(PG_FUNCTION_ARGS)886 regexp_match_no_flags(PG_FUNCTION_ARGS)
887 {
888 return regexp_match(fcinfo);
889 }
890
891 /*
892 * regexp_matches()
893 * Return a table of all matches of a pattern within a string.
894 */
895 Datum
regexp_matches(PG_FUNCTION_ARGS)896 regexp_matches(PG_FUNCTION_ARGS)
897 {
898 FuncCallContext *funcctx;
899 regexp_matches_ctx *matchctx;
900
901 if (SRF_IS_FIRSTCALL())
902 {
903 text *pattern = PG_GETARG_TEXT_PP(1);
904 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
905 pg_re_flags re_flags;
906 MemoryContext oldcontext;
907
908 funcctx = SRF_FIRSTCALL_INIT();
909 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
910
911 /* Determine options */
912 parse_re_flags(&re_flags, flags);
913
914 /* be sure to copy the input string into the multi-call ctx */
915 matchctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
916 &re_flags,
917 PG_GET_COLLATION(),
918 true, false, false);
919
920 /* Pre-create workspace that build_regexp_match_result needs */
921 matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
922 matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
923
924 MemoryContextSwitchTo(oldcontext);
925 funcctx->user_fctx = (void *) matchctx;
926 }
927
928 funcctx = SRF_PERCALL_SETUP();
929 matchctx = (regexp_matches_ctx *) funcctx->user_fctx;
930
931 if (matchctx->next_match < matchctx->nmatches)
932 {
933 ArrayType *result_ary;
934
935 result_ary = build_regexp_match_result(matchctx);
936 matchctx->next_match++;
937 SRF_RETURN_NEXT(funcctx, PointerGetDatum(result_ary));
938 }
939
940 SRF_RETURN_DONE(funcctx);
941 }
942
943 /* This is separate to keep the opr_sanity regression test from complaining */
944 Datum
regexp_matches_no_flags(PG_FUNCTION_ARGS)945 regexp_matches_no_flags(PG_FUNCTION_ARGS)
946 {
947 return regexp_matches(fcinfo);
948 }
949
950 /*
951 * setup_regexp_matches --- do the initial matching for regexp_match
952 * and regexp_split functions
953 *
954 * To avoid having to re-find the compiled pattern on each call, we do
955 * all the matching in one swoop. The returned regexp_matches_ctx contains
956 * the locations of all the substrings matching the pattern.
957 *
958 * The three bool parameters have only two patterns (one for matching, one for
959 * splitting) but it seems clearer to distinguish the functionality this way
960 * than to key it all off one "is_split" flag. We don't currently assume that
961 * fetching_unmatched is exclusive of fetching the matched text too; if it's
962 * set, the conversion buffer is large enough to fetch any single matched or
963 * unmatched string, but not any larger substring. (In practice, when splitting
964 * the matches are usually small anyway, and it didn't seem worth complicating
965 * the code further.)
966 */
967 static regexp_matches_ctx *
setup_regexp_matches(text * orig_str,text * pattern,pg_re_flags * re_flags,Oid collation,bool use_subpatterns,bool ignore_degenerate,bool fetching_unmatched)968 setup_regexp_matches(text *orig_str, text *pattern, pg_re_flags *re_flags,
969 Oid collation,
970 bool use_subpatterns,
971 bool ignore_degenerate,
972 bool fetching_unmatched)
973 {
974 regexp_matches_ctx *matchctx = palloc0(sizeof(regexp_matches_ctx));
975 int eml = pg_database_encoding_max_length();
976 int orig_len;
977 pg_wchar *wide_str;
978 int wide_len;
979 regex_t *cpattern;
980 regmatch_t *pmatch;
981 int pmatch_len;
982 int array_len;
983 int array_idx;
984 int prev_match_end;
985 int prev_valid_match_end;
986 int start_search;
987 int maxlen = 0; /* largest fetch length in characters */
988
989 /* save original string --- we'll extract result substrings from it */
990 matchctx->orig_str = orig_str;
991
992 /* convert string to pg_wchar form for matching */
993 orig_len = VARSIZE_ANY_EXHDR(orig_str);
994 wide_str = (pg_wchar *) palloc(sizeof(pg_wchar) * (orig_len + 1));
995 wide_len = pg_mb2wchar_with_len(VARDATA_ANY(orig_str), wide_str, orig_len);
996
997 /* set up the compiled pattern */
998 cpattern = RE_compile_and_cache(pattern, re_flags->cflags, collation);
999
1000 /* do we want to remember subpatterns? */
1001 if (use_subpatterns && cpattern->re_nsub > 0)
1002 {
1003 matchctx->npatterns = cpattern->re_nsub;
1004 pmatch_len = cpattern->re_nsub + 1;
1005 }
1006 else
1007 {
1008 use_subpatterns = false;
1009 matchctx->npatterns = 1;
1010 pmatch_len = 1;
1011 }
1012
1013 /* temporary output space for RE package */
1014 pmatch = palloc(sizeof(regmatch_t) * pmatch_len);
1015
1016 /*
1017 * the real output space (grown dynamically if needed)
1018 *
1019 * use values 2^n-1, not 2^n, so that we hit the limit at 2^28-1 rather
1020 * than at 2^27
1021 */
1022 array_len = re_flags->glob ? 255 : 31;
1023 matchctx->match_locs = (int *) palloc(sizeof(int) * array_len);
1024 array_idx = 0;
1025
1026 /* search for the pattern, perhaps repeatedly */
1027 prev_match_end = 0;
1028 prev_valid_match_end = 0;
1029 start_search = 0;
1030 while (RE_wchar_execute(cpattern, wide_str, wide_len, start_search,
1031 pmatch_len, pmatch))
1032 {
1033 /*
1034 * If requested, ignore degenerate matches, which are zero-length
1035 * matches occurring at the start or end of a string or just after a
1036 * previous match.
1037 */
1038 if (!ignore_degenerate ||
1039 (pmatch[0].rm_so < wide_len &&
1040 pmatch[0].rm_eo > prev_match_end))
1041 {
1042 /* enlarge output space if needed */
1043 while (array_idx + matchctx->npatterns * 2 + 1 > array_len)
1044 {
1045 array_len += array_len + 1; /* 2^n-1 => 2^(n+1)-1 */
1046 if (array_len > MaxAllocSize/sizeof(int))
1047 ereport(ERROR,
1048 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1049 errmsg("too many regular expression matches")));
1050 matchctx->match_locs = (int *) repalloc(matchctx->match_locs,
1051 sizeof(int) * array_len);
1052 }
1053
1054 /* save this match's locations */
1055 if (use_subpatterns)
1056 {
1057 int i;
1058
1059 for (i = 1; i <= matchctx->npatterns; i++)
1060 {
1061 int so = pmatch[i].rm_so;
1062 int eo = pmatch[i].rm_eo;
1063 matchctx->match_locs[array_idx++] = so;
1064 matchctx->match_locs[array_idx++] = eo;
1065 if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
1066 maxlen = (eo - so);
1067 }
1068 }
1069 else
1070 {
1071 int so = pmatch[0].rm_so;
1072 int eo = pmatch[0].rm_eo;
1073 matchctx->match_locs[array_idx++] = so;
1074 matchctx->match_locs[array_idx++] = eo;
1075 if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
1076 maxlen = (eo - so);
1077 }
1078 matchctx->nmatches++;
1079
1080 /*
1081 * check length of unmatched portion between end of previous valid
1082 * (nondegenerate, or degenerate but not ignored) match and start
1083 * of current one
1084 */
1085 if (fetching_unmatched &&
1086 pmatch[0].rm_so >= 0 &&
1087 (pmatch[0].rm_so - prev_valid_match_end) > maxlen)
1088 maxlen = (pmatch[0].rm_so - prev_valid_match_end);
1089 prev_valid_match_end = pmatch[0].rm_eo;
1090 }
1091 prev_match_end = pmatch[0].rm_eo;
1092
1093 /* if not glob, stop after one match */
1094 if (!re_flags->glob)
1095 break;
1096
1097 /*
1098 * Advance search position. Normally we start the next search at the
1099 * end of the previous match; but if the match was of zero length, we
1100 * have to advance by one character, or we'd just find the same match
1101 * again.
1102 */
1103 start_search = prev_match_end;
1104 if (pmatch[0].rm_so == pmatch[0].rm_eo)
1105 start_search++;
1106 if (start_search > wide_len)
1107 break;
1108 }
1109
1110 /*
1111 * check length of unmatched portion between end of last match and end of
1112 * input string
1113 */
1114 if (fetching_unmatched &&
1115 (wide_len - prev_valid_match_end) > maxlen)
1116 maxlen = (wide_len - prev_valid_match_end);
1117
1118 /*
1119 * Keep a note of the end position of the string for the benefit of
1120 * splitting code.
1121 */
1122 matchctx->match_locs[array_idx] = wide_len;
1123
1124 if (eml > 1)
1125 {
1126 int64 maxsiz = eml * (int64) maxlen;
1127 int conv_bufsiz;
1128
1129 /*
1130 * Make the conversion buffer large enough for any substring of
1131 * interest.
1132 *
1133 * Worst case: assume we need the maximum size (maxlen*eml), but take
1134 * advantage of the fact that the original string length in bytes is an
1135 * upper bound on the byte length of any fetched substring (and we know
1136 * that len+1 is safe to allocate because the varlena header is longer
1137 * than 1 byte).
1138 */
1139 if (maxsiz > orig_len)
1140 conv_bufsiz = orig_len + 1;
1141 else
1142 conv_bufsiz = maxsiz + 1; /* safe since maxsiz < 2^30 */
1143
1144 matchctx->conv_buf = palloc(conv_bufsiz);
1145 matchctx->conv_bufsiz = conv_bufsiz;
1146 matchctx->wide_str = wide_str;
1147 }
1148 else
1149 {
1150 /* No need to keep the wide string if we're in a single-byte charset. */
1151 pfree(wide_str);
1152 matchctx->wide_str = NULL;
1153 matchctx->conv_buf = NULL;
1154 matchctx->conv_bufsiz = 0;
1155 }
1156
1157 /* Clean up temp storage */
1158 pfree(pmatch);
1159
1160 return matchctx;
1161 }
1162
1163 /*
1164 * build_regexp_match_result - build output array for current match
1165 */
1166 static ArrayType *
build_regexp_match_result(regexp_matches_ctx * matchctx)1167 build_regexp_match_result(regexp_matches_ctx *matchctx)
1168 {
1169 char *buf = matchctx->conv_buf;
1170 int bufsiz PG_USED_FOR_ASSERTS_ONLY = matchctx->conv_bufsiz;
1171 Datum *elems = matchctx->elems;
1172 bool *nulls = matchctx->nulls;
1173 int dims[1];
1174 int lbs[1];
1175 int loc;
1176 int i;
1177
1178 /* Extract matching substrings from the original string */
1179 loc = matchctx->next_match * matchctx->npatterns * 2;
1180 for (i = 0; i < matchctx->npatterns; i++)
1181 {
1182 int so = matchctx->match_locs[loc++];
1183 int eo = matchctx->match_locs[loc++];
1184
1185 if (so < 0 || eo < 0)
1186 {
1187 elems[i] = (Datum) 0;
1188 nulls[i] = true;
1189 }
1190 else if (buf)
1191 {
1192 int len = pg_wchar2mb_with_len(matchctx->wide_str + so,
1193 buf,
1194 eo - so);
1195 Assert(len < bufsiz);
1196 elems[i] = PointerGetDatum(cstring_to_text_with_len(buf, len));
1197 nulls[i] = false;
1198 }
1199 else
1200 {
1201 elems[i] = DirectFunctionCall3(text_substr,
1202 PointerGetDatum(matchctx->orig_str),
1203 Int32GetDatum(so + 1),
1204 Int32GetDatum(eo - so));
1205 nulls[i] = false;
1206 }
1207 }
1208
1209 /* And form an array */
1210 dims[0] = matchctx->npatterns;
1211 lbs[0] = 1;
1212 /* XXX: this hardcodes assumptions about the text type */
1213 return construct_md_array(elems, nulls, 1, dims, lbs,
1214 TEXTOID, -1, false, 'i');
1215 }
1216
1217 /*
1218 * regexp_split_to_table()
1219 * Split the string at matches of the pattern, returning the
1220 * split-out substrings as a table.
1221 */
1222 Datum
regexp_split_to_table(PG_FUNCTION_ARGS)1223 regexp_split_to_table(PG_FUNCTION_ARGS)
1224 {
1225 FuncCallContext *funcctx;
1226 regexp_matches_ctx *splitctx;
1227
1228 if (SRF_IS_FIRSTCALL())
1229 {
1230 text *pattern = PG_GETARG_TEXT_PP(1);
1231 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1232 pg_re_flags re_flags;
1233 MemoryContext oldcontext;
1234
1235 funcctx = SRF_FIRSTCALL_INIT();
1236 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1237
1238 /* Determine options */
1239 parse_re_flags(&re_flags, flags);
1240 /* User mustn't specify 'g' */
1241 if (re_flags.glob)
1242 ereport(ERROR,
1243 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1244 errmsg("regexp_split_to_table does not support the global option")));
1245 /* But we find all the matches anyway */
1246 re_flags.glob = true;
1247
1248 /* be sure to copy the input string into the multi-call ctx */
1249 splitctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
1250 &re_flags,
1251 PG_GET_COLLATION(),
1252 false, true, true);
1253
1254 MemoryContextSwitchTo(oldcontext);
1255 funcctx->user_fctx = (void *) splitctx;
1256 }
1257
1258 funcctx = SRF_PERCALL_SETUP();
1259 splitctx = (regexp_matches_ctx *) funcctx->user_fctx;
1260
1261 if (splitctx->next_match <= splitctx->nmatches)
1262 {
1263 Datum result = build_regexp_split_result(splitctx);
1264
1265 splitctx->next_match++;
1266 SRF_RETURN_NEXT(funcctx, result);
1267 }
1268
1269 SRF_RETURN_DONE(funcctx);
1270 }
1271
1272 /* This is separate to keep the opr_sanity regression test from complaining */
1273 Datum
regexp_split_to_table_no_flags(PG_FUNCTION_ARGS)1274 regexp_split_to_table_no_flags(PG_FUNCTION_ARGS)
1275 {
1276 return regexp_split_to_table(fcinfo);
1277 }
1278
1279 /*
1280 * regexp_split_to_array()
1281 * Split the string at matches of the pattern, returning the
1282 * split-out substrings as an array.
1283 */
1284 Datum
regexp_split_to_array(PG_FUNCTION_ARGS)1285 regexp_split_to_array(PG_FUNCTION_ARGS)
1286 {
1287 ArrayBuildState *astate = NULL;
1288 pg_re_flags re_flags;
1289 regexp_matches_ctx *splitctx;
1290
1291 /* Determine options */
1292 parse_re_flags(&re_flags, PG_GETARG_TEXT_PP_IF_EXISTS(2));
1293 /* User mustn't specify 'g' */
1294 if (re_flags.glob)
1295 ereport(ERROR,
1296 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1297 errmsg("regexp_split_to_array does not support the global option")));
1298 /* But we find all the matches anyway */
1299 re_flags.glob = true;
1300
1301 splitctx = setup_regexp_matches(PG_GETARG_TEXT_PP(0),
1302 PG_GETARG_TEXT_PP(1),
1303 &re_flags,
1304 PG_GET_COLLATION(),
1305 false, true, true);
1306
1307 while (splitctx->next_match <= splitctx->nmatches)
1308 {
1309 astate = accumArrayResult(astate,
1310 build_regexp_split_result(splitctx),
1311 false,
1312 TEXTOID,
1313 CurrentMemoryContext);
1314 splitctx->next_match++;
1315 }
1316
1317 PG_RETURN_ARRAYTYPE_P(makeArrayResult(astate, CurrentMemoryContext));
1318 }
1319
1320 /* This is separate to keep the opr_sanity regression test from complaining */
1321 Datum
regexp_split_to_array_no_flags(PG_FUNCTION_ARGS)1322 regexp_split_to_array_no_flags(PG_FUNCTION_ARGS)
1323 {
1324 return regexp_split_to_array(fcinfo);
1325 }
1326
1327 /*
1328 * build_regexp_split_result - build output string for current match
1329 *
1330 * We return the string between the current match and the previous one,
1331 * or the string after the last match when next_match == nmatches.
1332 */
1333 static Datum
build_regexp_split_result(regexp_matches_ctx * splitctx)1334 build_regexp_split_result(regexp_matches_ctx *splitctx)
1335 {
1336 char *buf = splitctx->conv_buf;
1337 int startpos;
1338 int endpos;
1339
1340 if (splitctx->next_match > 0)
1341 startpos = splitctx->match_locs[splitctx->next_match * 2 - 1];
1342 else
1343 startpos = 0;
1344 if (startpos < 0)
1345 elog(ERROR, "invalid match ending position");
1346
1347 if (buf)
1348 {
1349 int bufsiz PG_USED_FOR_ASSERTS_ONLY = splitctx->conv_bufsiz;
1350 int len;
1351
1352 endpos = splitctx->match_locs[splitctx->next_match * 2];
1353 if (endpos < startpos)
1354 elog(ERROR, "invalid match starting position");
1355 len = pg_wchar2mb_with_len(splitctx->wide_str + startpos,
1356 buf,
1357 endpos-startpos);
1358 Assert(len < bufsiz);
1359 return PointerGetDatum(cstring_to_text_with_len(buf, len));
1360 }
1361 else
1362 {
1363 endpos = splitctx->match_locs[splitctx->next_match * 2];
1364 if (endpos < startpos)
1365 elog(ERROR, "invalid match starting position");
1366 return DirectFunctionCall3(text_substr,
1367 PointerGetDatum(splitctx->orig_str),
1368 Int32GetDatum(startpos + 1),
1369 Int32GetDatum(endpos - startpos));
1370 }
1371 }
1372
1373 /*
1374 * regexp_fixed_prefix - extract fixed prefix, if any, for a regexp
1375 *
1376 * The result is NULL if there is no fixed prefix, else a palloc'd string.
1377 * If it is an exact match, not just a prefix, *exact is returned as true.
1378 */
1379 char *
regexp_fixed_prefix(text * text_re,bool case_insensitive,Oid collation,bool * exact)1380 regexp_fixed_prefix(text *text_re, bool case_insensitive, Oid collation,
1381 bool *exact)
1382 {
1383 char *result;
1384 regex_t *re;
1385 int cflags;
1386 int re_result;
1387 pg_wchar *str;
1388 size_t slen;
1389 size_t maxlen;
1390 char errMsg[100];
1391
1392 *exact = false; /* default result */
1393
1394 /* Compile RE */
1395 cflags = REG_ADVANCED;
1396 if (case_insensitive)
1397 cflags |= REG_ICASE;
1398
1399 re = RE_compile_and_cache(text_re, cflags, collation);
1400
1401 /* Examine it to see if there's a fixed prefix */
1402 re_result = pg_regprefix(re, &str, &slen);
1403
1404 switch (re_result)
1405 {
1406 case REG_NOMATCH:
1407 return NULL;
1408
1409 case REG_PREFIX:
1410 /* continue with wchar conversion */
1411 break;
1412
1413 case REG_EXACT:
1414 *exact = true;
1415 /* continue with wchar conversion */
1416 break;
1417
1418 default:
1419 /* re failed??? */
1420 CHECK_FOR_INTERRUPTS();
1421 pg_regerror(re_result, re, errMsg, sizeof(errMsg));
1422 ereport(ERROR,
1423 (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
1424 errmsg("regular expression failed: %s", errMsg)));
1425 break;
1426 }
1427
1428 /* Convert pg_wchar result back to database encoding */
1429 maxlen = pg_database_encoding_max_length() * slen + 1;
1430 result = (char *) palloc(maxlen);
1431 slen = pg_wchar2mb_with_len(str, result, slen);
1432 Assert(slen < maxlen);
1433
1434 free(str);
1435
1436 return result;
1437 }
1438