PostgreSQL Source Code  git master
regexp.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * regexp.c
4  * Postgres' interface to the regular expression package.
5  *
6  * Portions Copyright (c) 1996-2019, 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 */
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);
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 regex_t *
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  */
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
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??? */
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
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 bool
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
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 regular expression 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
441 {
442  Name n = PG_GETARG_NAME(0);
443  text *p = PG_GETARG_TEXT_PP(1);
444 
446  NameStr(*n),
447  strlen(NameStr(*n)),
448  REG_ADVANCED,
450  0, NULL));
451 }
452 
453 Datum
455 {
456  Name n = PG_GETARG_NAME(0);
457  text *p = PG_GETARG_TEXT_PP(1);
458 
460  NameStr(*n),
461  strlen(NameStr(*n)),
462  REG_ADVANCED,
464  0, NULL));
465 }
466 
467 Datum
469 {
470  text *s = PG_GETARG_TEXT_PP(0);
471  text *p = PG_GETARG_TEXT_PP(1);
472 
474  VARDATA_ANY(s),
476  REG_ADVANCED,
478  0, NULL));
479 }
480 
481 Datum
483 {
484  text *s = PG_GETARG_TEXT_PP(0);
485  text *p = PG_GETARG_TEXT_PP(1);
486 
488  VARDATA_ANY(s),
490  REG_ADVANCED,
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
504 {
505  Name n = PG_GETARG_NAME(0);
506  text *p = PG_GETARG_TEXT_PP(1);
507 
509  NameStr(*n),
510  strlen(NameStr(*n)),
513  0, NULL));
514 }
515 
516 Datum
518 {
519  Name n = PG_GETARG_NAME(0);
520  text *p = PG_GETARG_TEXT_PP(1);
521 
523  NameStr(*n),
524  strlen(NameStr(*n)),
527  0, NULL));
528 }
529 
530 Datum
532 {
533  text *s = PG_GETARG_TEXT_PP(0);
534  text *p = PG_GETARG_TEXT_PP(1);
535 
537  VARDATA_ANY(s),
541  0, NULL));
542 }
543 
544 Datum
546 {
547  text *s = PG_GETARG_TEXT_PP(0);
548  text *p = PG_GETARG_TEXT_PP(1);
549 
551  VARDATA_ANY(s),
555  0, NULL));
556 }
557 
558 
559 /*
560  * textregexsubstr()
561  * Return a substring matched by a regular expression.
562  */
563 Datum
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 */
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,
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 
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
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 
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
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_to_escape(), similar_escape()
658  *
659  * Convert a SQL "SIMILAR TO" regexp pattern to POSIX style, so it can be
660  * used by our regexp engine.
661  *
662  * similar_escape_internal() is the common workhorse for three SQL-exposed
663  * functions. esc_text can be passed as NULL to select the default escape
664  * (which is '\'), or as an empty string to select no escape character.
665  */
666 static text *
667 similar_escape_internal(text *pat_text, text *esc_text)
668 {
669  text *result;
670  char *p,
671  *e,
672  *r;
673  int plen,
674  elen;
675  bool afterescape = false;
676  bool incharclass = false;
677  int nquotes = 0;
678 
679  p = VARDATA_ANY(pat_text);
680  plen = VARSIZE_ANY_EXHDR(pat_text);
681  if (esc_text == NULL)
682  {
683  /* No ESCAPE clause provided; default to backslash as escape */
684  e = "\\";
685  elen = 1;
686  }
687  else
688  {
689  e = VARDATA_ANY(esc_text);
690  elen = VARSIZE_ANY_EXHDR(esc_text);
691  if (elen == 0)
692  e = NULL; /* no escape character */
693  else if (elen > 1)
694  {
695  int escape_mblen = pg_mbstrlen_with_len(e, elen);
696 
697  if (escape_mblen > 1)
698  ereport(ERROR,
699  (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
700  errmsg("invalid escape string"),
701  errhint("Escape string must be empty or one character.")));
702  }
703  }
704 
705  /*----------
706  * We surround the transformed input string with
707  * ^(?: ... )$
708  * which requires some explanation. We need "^" and "$" to force
709  * the pattern to match the entire input string as per the SQL spec.
710  * The "(?:" and ")" are a non-capturing set of parens; we have to have
711  * parens in case the string contains "|", else the "^" and "$" will
712  * be bound into the first and last alternatives which is not what we
713  * want, and the parens must be non capturing because we don't want them
714  * to count when selecting output for SUBSTRING.
715  *
716  * When the pattern is divided into three parts by escape-double-quotes,
717  * what we emit is
718  * ^(?:part1){1,1}?(part2){1,1}(?:part3)$
719  * which requires even more explanation. The "{1,1}?" on part1 makes it
720  * non-greedy so that it will match the smallest possible amount of text
721  * not the largest, as required by SQL. The plain parens around part2
722  * are capturing parens so that that part is what controls the result of
723  * SUBSTRING. The "{1,1}" forces part2 to be greedy, so that it matches
724  * the largest possible amount of text; hence part3 must match the
725  * smallest amount of text, as required by SQL. We don't need an explicit
726  * greediness marker on part3. Note that this also confines the effects
727  * of any "|" characters to the respective part, which is what we want.
728  *
729  * The SQL spec says that SUBSTRING's pattern must contain exactly two
730  * escape-double-quotes, but we only complain if there's more than two.
731  * With none, we act as though part1 and part3 are empty; with one, we
732  * act as though part3 is empty. Both behaviors fall out of omitting
733  * the relevant part separators in the above expansion. If the result
734  * of this function is used in a plain regexp match (SIMILAR TO), the
735  * escape-double-quotes have no effect on the match behavior.
736  *----------
737  */
738 
739  /*
740  * We need room for the prefix/postfix and part separators, plus as many
741  * as 3 output bytes per input byte; since the input is at most 1GB this
742  * can't overflow size_t.
743  */
744  result = (text *) palloc(VARHDRSZ + 23 + 3 * (size_t) plen);
745  r = VARDATA(result);
746 
747  *r++ = '^';
748  *r++ = '(';
749  *r++ = '?';
750  *r++ = ':';
751 
752  while (plen > 0)
753  {
754  char pchar = *p;
755 
756  /*
757  * If both the escape character and the current character from the
758  * pattern are multi-byte, we need to take the slow path.
759  *
760  * But if one of them is single-byte, we can process the pattern one
761  * byte at a time, ignoring multi-byte characters. (This works
762  * because all server-encodings have the property that a valid
763  * multi-byte character representation cannot contain the
764  * representation of a valid single-byte character.)
765  */
766 
767  if (elen > 1)
768  {
769  int mblen = pg_mblen(p);
770 
771  if (mblen > 1)
772  {
773  /* slow, multi-byte path */
774  if (afterescape)
775  {
776  *r++ = '\\';
777  memcpy(r, p, mblen);
778  r += mblen;
779  afterescape = false;
780  }
781  else if (e && elen == mblen && memcmp(e, p, mblen) == 0)
782  {
783  /* SQL escape character; do not send to output */
784  afterescape = true;
785  }
786  else
787  {
788  /*
789  * We know it's a multi-byte character, so we don't need
790  * to do all the comparisons to single-byte characters
791  * that we do below.
792  */
793  memcpy(r, p, mblen);
794  r += mblen;
795  }
796 
797  p += mblen;
798  plen -= mblen;
799 
800  continue;
801  }
802  }
803 
804  /* fast path */
805  if (afterescape)
806  {
807  if (pchar == '"' && !incharclass) /* escape-double-quote? */
808  {
809  /* emit appropriate part separator, per notes above */
810  if (nquotes == 0)
811  {
812  *r++ = ')';
813  *r++ = '{';
814  *r++ = '1';
815  *r++ = ',';
816  *r++ = '1';
817  *r++ = '}';
818  *r++ = '?';
819  *r++ = '(';
820  }
821  else if (nquotes == 1)
822  {
823  *r++ = ')';
824  *r++ = '{';
825  *r++ = '1';
826  *r++ = ',';
827  *r++ = '1';
828  *r++ = '}';
829  *r++ = '(';
830  *r++ = '?';
831  *r++ = ':';
832  }
833  else
834  ereport(ERROR,
835  (errcode(ERRCODE_INVALID_USE_OF_ESCAPE_CHARACTER),
836  errmsg("SQL regular expression may not contain more than two escape-double-quote separators")));
837  nquotes++;
838  }
839  else
840  {
841  /*
842  * We allow any character at all to be escaped; notably, this
843  * allows access to POSIX character-class escapes such as
844  * "\d". The SQL spec is considerably more restrictive.
845  */
846  *r++ = '\\';
847  *r++ = pchar;
848  }
849  afterescape = false;
850  }
851  else if (e && pchar == *e)
852  {
853  /* SQL escape character; do not send to output */
854  afterescape = true;
855  }
856  else if (incharclass)
857  {
858  if (pchar == '\\')
859  *r++ = '\\';
860  *r++ = pchar;
861  if (pchar == ']')
862  incharclass = false;
863  }
864  else if (pchar == '[')
865  {
866  *r++ = pchar;
867  incharclass = true;
868  }
869  else if (pchar == '%')
870  {
871  *r++ = '.';
872  *r++ = '*';
873  }
874  else if (pchar == '_')
875  *r++ = '.';
876  else if (pchar == '(')
877  {
878  /* convert to non-capturing parenthesis */
879  *r++ = '(';
880  *r++ = '?';
881  *r++ = ':';
882  }
883  else if (pchar == '\\' || pchar == '.' ||
884  pchar == '^' || pchar == '$')
885  {
886  *r++ = '\\';
887  *r++ = pchar;
888  }
889  else
890  *r++ = pchar;
891  p++, plen--;
892  }
893 
894  *r++ = ')';
895  *r++ = '$';
896 
897  SET_VARSIZE(result, r - ((char *) result));
898 
899  return result;
900 }
901 
902 /*
903  * similar_to_escape(pattern, escape)
904  */
905 Datum
907 {
908  text *pat_text = PG_GETARG_TEXT_PP(0);
909  text *esc_text = PG_GETARG_TEXT_PP(1);
910  text *result;
911 
912  result = similar_escape_internal(pat_text, esc_text);
913 
914  PG_RETURN_TEXT_P(result);
915 }
916 
917 /*
918  * similar_to_escape(pattern)
919  * Inserts a default escape character.
920  */
921 Datum
923 {
924  text *pat_text = PG_GETARG_TEXT_PP(0);
925  text *result;
926 
927  result = similar_escape_internal(pat_text, NULL);
928 
929  PG_RETURN_TEXT_P(result);
930 }
931 
932 /*
933  * similar_escape(pattern, escape)
934  *
935  * Legacy function for compatibility with views stored using the
936  * pre-v13 expansion of SIMILAR TO. Unlike the above functions, this
937  * is non-strict, which leads to not-per-spec handling of "ESCAPE NULL".
938  */
939 Datum
941 {
942  text *pat_text;
943  text *esc_text;
944  text *result;
945 
946  /* This function is not strict, so must test explicitly */
947  if (PG_ARGISNULL(0))
948  PG_RETURN_NULL();
949  pat_text = PG_GETARG_TEXT_PP(0);
950 
951  if (PG_ARGISNULL(1))
952  esc_text = NULL; /* use default escape character */
953  else
954  esc_text = PG_GETARG_TEXT_PP(1);
955 
956  result = similar_escape_internal(pat_text, esc_text);
957 
958  PG_RETURN_TEXT_P(result);
959 }
960 
961 /*
962  * regexp_match()
963  * Return the first substring(s) matching a pattern within a string.
964  */
965 Datum
967 {
968  text *orig_str = PG_GETARG_TEXT_PP(0);
969  text *pattern = PG_GETARG_TEXT_PP(1);
970  text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
971  pg_re_flags re_flags;
972  regexp_matches_ctx *matchctx;
973 
974  /* Determine options */
975  parse_re_flags(&re_flags, flags);
976  /* User mustn't specify 'g' */
977  if (re_flags.glob)
978  ereport(ERROR,
979  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
980  /* translator: %s is a SQL function name */
981  errmsg("%s does not support the \"global\" option",
982  "regexp_match()"),
983  errhint("Use the regexp_matches function instead.")));
984 
985  matchctx = setup_regexp_matches(orig_str, pattern, &re_flags,
986  PG_GET_COLLATION(), true, false, false);
987 
988  if (matchctx->nmatches == 0)
989  PG_RETURN_NULL();
990 
991  Assert(matchctx->nmatches == 1);
992 
993  /* Create workspace that build_regexp_match_result needs */
994  matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
995  matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
996 
998 }
999 
1000 /* This is separate to keep the opr_sanity regression test from complaining */
1001 Datum
1003 {
1004  return regexp_match(fcinfo);
1005 }
1006 
1007 /*
1008  * regexp_matches()
1009  * Return a table of all matches of a pattern within a string.
1010  */
1011 Datum
1013 {
1014  FuncCallContext *funcctx;
1015  regexp_matches_ctx *matchctx;
1016 
1017  if (SRF_IS_FIRSTCALL())
1018  {
1019  text *pattern = PG_GETARG_TEXT_PP(1);
1020  text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1021  pg_re_flags re_flags;
1022  MemoryContext oldcontext;
1023 
1024  funcctx = SRF_FIRSTCALL_INIT();
1025  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1026 
1027  /* Determine options */
1028  parse_re_flags(&re_flags, flags);
1029 
1030  /* be sure to copy the input string into the multi-call ctx */
1031  matchctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
1032  &re_flags,
1033  PG_GET_COLLATION(),
1034  true, false, false);
1035 
1036  /* Pre-create workspace that build_regexp_match_result needs */
1037  matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
1038  matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
1039 
1040  MemoryContextSwitchTo(oldcontext);
1041  funcctx->user_fctx = (void *) matchctx;
1042  }
1043 
1044  funcctx = SRF_PERCALL_SETUP();
1045  matchctx = (regexp_matches_ctx *) funcctx->user_fctx;
1046 
1047  if (matchctx->next_match < matchctx->nmatches)
1048  {
1049  ArrayType *result_ary;
1050 
1051  result_ary = build_regexp_match_result(matchctx);
1052  matchctx->next_match++;
1053  SRF_RETURN_NEXT(funcctx, PointerGetDatum(result_ary));
1054  }
1055 
1056  SRF_RETURN_DONE(funcctx);
1057 }
1058 
1059 /* This is separate to keep the opr_sanity regression test from complaining */
1060 Datum
1062 {
1063  return regexp_matches(fcinfo);
1064 }
1065 
1066 /*
1067  * setup_regexp_matches --- do the initial matching for regexp_match
1068  * and regexp_split functions
1069  *
1070  * To avoid having to re-find the compiled pattern on each call, we do
1071  * all the matching in one swoop. The returned regexp_matches_ctx contains
1072  * the locations of all the substrings matching the pattern.
1073  *
1074  * The three bool parameters have only two patterns (one for matching, one for
1075  * splitting) but it seems clearer to distinguish the functionality this way
1076  * than to key it all off one "is_split" flag. We don't currently assume that
1077  * fetching_unmatched is exclusive of fetching the matched text too; if it's
1078  * set, the conversion buffer is large enough to fetch any single matched or
1079  * unmatched string, but not any larger substring. (In practice, when splitting
1080  * the matches are usually small anyway, and it didn't seem worth complicating
1081  * the code further.)
1082  */
1083 static regexp_matches_ctx *
1084 setup_regexp_matches(text *orig_str, text *pattern, pg_re_flags *re_flags,
1085  Oid collation,
1086  bool use_subpatterns,
1087  bool ignore_degenerate,
1088  bool fetching_unmatched)
1089 {
1090  regexp_matches_ctx *matchctx = palloc0(sizeof(regexp_matches_ctx));
1091  int eml = pg_database_encoding_max_length();
1092  int orig_len;
1093  pg_wchar *wide_str;
1094  int wide_len;
1095  regex_t *cpattern;
1096  regmatch_t *pmatch;
1097  int pmatch_len;
1098  int array_len;
1099  int array_idx;
1100  int prev_match_end;
1101  int prev_valid_match_end;
1102  int start_search;
1103  int maxlen = 0; /* largest fetch length in characters */
1104 
1105  /* save original string --- we'll extract result substrings from it */
1106  matchctx->orig_str = orig_str;
1107 
1108  /* convert string to pg_wchar form for matching */
1109  orig_len = VARSIZE_ANY_EXHDR(orig_str);
1110  wide_str = (pg_wchar *) palloc(sizeof(pg_wchar) * (orig_len + 1));
1111  wide_len = pg_mb2wchar_with_len(VARDATA_ANY(orig_str), wide_str, orig_len);
1112 
1113  /* set up the compiled pattern */
1114  cpattern = RE_compile_and_cache(pattern, re_flags->cflags, collation);
1115 
1116  /* do we want to remember subpatterns? */
1117  if (use_subpatterns && cpattern->re_nsub > 0)
1118  {
1119  matchctx->npatterns = cpattern->re_nsub;
1120  pmatch_len = cpattern->re_nsub + 1;
1121  }
1122  else
1123  {
1124  use_subpatterns = false;
1125  matchctx->npatterns = 1;
1126  pmatch_len = 1;
1127  }
1128 
1129  /* temporary output space for RE package */
1130  pmatch = palloc(sizeof(regmatch_t) * pmatch_len);
1131 
1132  /*
1133  * the real output space (grown dynamically if needed)
1134  *
1135  * use values 2^n-1, not 2^n, so that we hit the limit at 2^28-1 rather
1136  * than at 2^27
1137  */
1138  array_len = re_flags->glob ? 255 : 31;
1139  matchctx->match_locs = (int *) palloc(sizeof(int) * array_len);
1140  array_idx = 0;
1141 
1142  /* search for the pattern, perhaps repeatedly */
1143  prev_match_end = 0;
1144  prev_valid_match_end = 0;
1145  start_search = 0;
1146  while (RE_wchar_execute(cpattern, wide_str, wide_len, start_search,
1147  pmatch_len, pmatch))
1148  {
1149  /*
1150  * If requested, ignore degenerate matches, which are zero-length
1151  * matches occurring at the start or end of a string or just after a
1152  * previous match.
1153  */
1154  if (!ignore_degenerate ||
1155  (pmatch[0].rm_so < wide_len &&
1156  pmatch[0].rm_eo > prev_match_end))
1157  {
1158  /* enlarge output space if needed */
1159  while (array_idx + matchctx->npatterns * 2 + 1 > array_len)
1160  {
1161  array_len += array_len + 1; /* 2^n-1 => 2^(n+1)-1 */
1162  if (array_len > MaxAllocSize / sizeof(int))
1163  ereport(ERROR,
1164  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1165  errmsg("too many regular expression matches")));
1166  matchctx->match_locs = (int *) repalloc(matchctx->match_locs,
1167  sizeof(int) * array_len);
1168  }
1169 
1170  /* save this match's locations */
1171  if (use_subpatterns)
1172  {
1173  int i;
1174 
1175  for (i = 1; i <= matchctx->npatterns; i++)
1176  {
1177  int so = pmatch[i].rm_so;
1178  int eo = pmatch[i].rm_eo;
1179 
1180  matchctx->match_locs[array_idx++] = so;
1181  matchctx->match_locs[array_idx++] = eo;
1182  if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
1183  maxlen = (eo - so);
1184  }
1185  }
1186  else
1187  {
1188  int so = pmatch[0].rm_so;
1189  int eo = pmatch[0].rm_eo;
1190 
1191  matchctx->match_locs[array_idx++] = so;
1192  matchctx->match_locs[array_idx++] = eo;
1193  if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
1194  maxlen = (eo - so);
1195  }
1196  matchctx->nmatches++;
1197 
1198  /*
1199  * check length of unmatched portion between end of previous valid
1200  * (nondegenerate, or degenerate but not ignored) match and start
1201  * of current one
1202  */
1203  if (fetching_unmatched &&
1204  pmatch[0].rm_so >= 0 &&
1205  (pmatch[0].rm_so - prev_valid_match_end) > maxlen)
1206  maxlen = (pmatch[0].rm_so - prev_valid_match_end);
1207  prev_valid_match_end = pmatch[0].rm_eo;
1208  }
1209  prev_match_end = pmatch[0].rm_eo;
1210 
1211  /* if not glob, stop after one match */
1212  if (!re_flags->glob)
1213  break;
1214 
1215  /*
1216  * Advance search position. Normally we start the next search at the
1217  * end of the previous match; but if the match was of zero length, we
1218  * have to advance by one character, or we'd just find the same match
1219  * again.
1220  */
1221  start_search = prev_match_end;
1222  if (pmatch[0].rm_so == pmatch[0].rm_eo)
1223  start_search++;
1224  if (start_search > wide_len)
1225  break;
1226  }
1227 
1228  /*
1229  * check length of unmatched portion between end of last match and end of
1230  * input string
1231  */
1232  if (fetching_unmatched &&
1233  (wide_len - prev_valid_match_end) > maxlen)
1234  maxlen = (wide_len - prev_valid_match_end);
1235 
1236  /*
1237  * Keep a note of the end position of the string for the benefit of
1238  * splitting code.
1239  */
1240  matchctx->match_locs[array_idx] = wide_len;
1241 
1242  if (eml > 1)
1243  {
1244  int64 maxsiz = eml * (int64) maxlen;
1245  int conv_bufsiz;
1246 
1247  /*
1248  * Make the conversion buffer large enough for any substring of
1249  * interest.
1250  *
1251  * Worst case: assume we need the maximum size (maxlen*eml), but take
1252  * advantage of the fact that the original string length in bytes is
1253  * an upper bound on the byte length of any fetched substring (and we
1254  * know that len+1 is safe to allocate because the varlena header is
1255  * longer than 1 byte).
1256  */
1257  if (maxsiz > orig_len)
1258  conv_bufsiz = orig_len + 1;
1259  else
1260  conv_bufsiz = maxsiz + 1; /* safe since maxsiz < 2^30 */
1261 
1262  matchctx->conv_buf = palloc(conv_bufsiz);
1263  matchctx->conv_bufsiz = conv_bufsiz;
1264  matchctx->wide_str = wide_str;
1265  }
1266  else
1267  {
1268  /* No need to keep the wide string if we're in a single-byte charset. */
1269  pfree(wide_str);
1270  matchctx->wide_str = NULL;
1271  matchctx->conv_buf = NULL;
1272  matchctx->conv_bufsiz = 0;
1273  }
1274 
1275  /* Clean up temp storage */
1276  pfree(pmatch);
1277 
1278  return matchctx;
1279 }
1280 
1281 /*
1282  * build_regexp_match_result - build output array for current match
1283  */
1284 static ArrayType *
1286 {
1287  char *buf = matchctx->conv_buf;
1288  int bufsiz PG_USED_FOR_ASSERTS_ONLY = matchctx->conv_bufsiz;
1289  Datum *elems = matchctx->elems;
1290  bool *nulls = matchctx->nulls;
1291  int dims[1];
1292  int lbs[1];
1293  int loc;
1294  int i;
1295 
1296  /* Extract matching substrings from the original string */
1297  loc = matchctx->next_match * matchctx->npatterns * 2;
1298  for (i = 0; i < matchctx->npatterns; i++)
1299  {
1300  int so = matchctx->match_locs[loc++];
1301  int eo = matchctx->match_locs[loc++];
1302 
1303  if (so < 0 || eo < 0)
1304  {
1305  elems[i] = (Datum) 0;
1306  nulls[i] = true;
1307  }
1308  else if (buf)
1309  {
1310  int len = pg_wchar2mb_with_len(matchctx->wide_str + so,
1311  buf,
1312  eo - so);
1313 
1314  Assert(len < bufsiz);
1315  elems[i] = PointerGetDatum(cstring_to_text_with_len(buf, len));
1316  nulls[i] = false;
1317  }
1318  else
1319  {
1321  PointerGetDatum(matchctx->orig_str),
1322  Int32GetDatum(so + 1),
1323  Int32GetDatum(eo - so));
1324  nulls[i] = false;
1325  }
1326  }
1327 
1328  /* And form an array */
1329  dims[0] = matchctx->npatterns;
1330  lbs[0] = 1;
1331  /* XXX: this hardcodes assumptions about the text type */
1332  return construct_md_array(elems, nulls, 1, dims, lbs,
1333  TEXTOID, -1, false, 'i');
1334 }
1335 
1336 /*
1337  * regexp_split_to_table()
1338  * Split the string at matches of the pattern, returning the
1339  * split-out substrings as a table.
1340  */
1341 Datum
1343 {
1344  FuncCallContext *funcctx;
1345  regexp_matches_ctx *splitctx;
1346 
1347  if (SRF_IS_FIRSTCALL())
1348  {
1349  text *pattern = PG_GETARG_TEXT_PP(1);
1350  text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1351  pg_re_flags re_flags;
1352  MemoryContext oldcontext;
1353 
1354  funcctx = SRF_FIRSTCALL_INIT();
1355  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1356 
1357  /* Determine options */
1358  parse_re_flags(&re_flags, flags);
1359  /* User mustn't specify 'g' */
1360  if (re_flags.glob)
1361  ereport(ERROR,
1362  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1363  /* translator: %s is a SQL function name */
1364  errmsg("%s does not support the \"global\" option",
1365  "regexp_split_to_table()")));
1366  /* But we find all the matches anyway */
1367  re_flags.glob = true;
1368 
1369  /* be sure to copy the input string into the multi-call ctx */
1370  splitctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
1371  &re_flags,
1372  PG_GET_COLLATION(),
1373  false, true, true);
1374 
1375  MemoryContextSwitchTo(oldcontext);
1376  funcctx->user_fctx = (void *) splitctx;
1377  }
1378 
1379  funcctx = SRF_PERCALL_SETUP();
1380  splitctx = (regexp_matches_ctx *) funcctx->user_fctx;
1381 
1382  if (splitctx->next_match <= splitctx->nmatches)
1383  {
1384  Datum result = build_regexp_split_result(splitctx);
1385 
1386  splitctx->next_match++;
1387  SRF_RETURN_NEXT(funcctx, result);
1388  }
1389 
1390  SRF_RETURN_DONE(funcctx);
1391 }
1392 
1393 /* This is separate to keep the opr_sanity regression test from complaining */
1394 Datum
1396 {
1397  return regexp_split_to_table(fcinfo);
1398 }
1399 
1400 /*
1401  * regexp_split_to_array()
1402  * Split the string at matches of the pattern, returning the
1403  * split-out substrings as an array.
1404  */
1405 Datum
1407 {
1408  ArrayBuildState *astate = NULL;
1409  pg_re_flags re_flags;
1410  regexp_matches_ctx *splitctx;
1411 
1412  /* Determine options */
1414  /* User mustn't specify 'g' */
1415  if (re_flags.glob)
1416  ereport(ERROR,
1417  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1418  /* translator: %s is a SQL function name */
1419  errmsg("%s does not support the \"global\" option",
1420  "regexp_split_to_array()")));
1421  /* But we find all the matches anyway */
1422  re_flags.glob = true;
1423 
1425  PG_GETARG_TEXT_PP(1),
1426  &re_flags,
1427  PG_GET_COLLATION(),
1428  false, true, true);
1429 
1430  while (splitctx->next_match <= splitctx->nmatches)
1431  {
1432  astate = accumArrayResult(astate,
1433  build_regexp_split_result(splitctx),
1434  false,
1435  TEXTOID,
1437  splitctx->next_match++;
1438  }
1439 
1441 }
1442 
1443 /* This is separate to keep the opr_sanity regression test from complaining */
1444 Datum
1446 {
1447  return regexp_split_to_array(fcinfo);
1448 }
1449 
1450 /*
1451  * build_regexp_split_result - build output string for current match
1452  *
1453  * We return the string between the current match and the previous one,
1454  * or the string after the last match when next_match == nmatches.
1455  */
1456 static Datum
1458 {
1459  char *buf = splitctx->conv_buf;
1460  int startpos;
1461  int endpos;
1462 
1463  if (splitctx->next_match > 0)
1464  startpos = splitctx->match_locs[splitctx->next_match * 2 - 1];
1465  else
1466  startpos = 0;
1467  if (startpos < 0)
1468  elog(ERROR, "invalid match ending position");
1469 
1470  if (buf)
1471  {
1472  int bufsiz PG_USED_FOR_ASSERTS_ONLY = splitctx->conv_bufsiz;
1473  int len;
1474 
1475  endpos = splitctx->match_locs[splitctx->next_match * 2];
1476  if (endpos < startpos)
1477  elog(ERROR, "invalid match starting position");
1478  len = pg_wchar2mb_with_len(splitctx->wide_str + startpos,
1479  buf,
1480  endpos - startpos);
1481  Assert(len < bufsiz);
1482  return PointerGetDatum(cstring_to_text_with_len(buf, len));
1483  }
1484  else
1485  {
1486  endpos = splitctx->match_locs[splitctx->next_match * 2];
1487  if (endpos < startpos)
1488  elog(ERROR, "invalid match starting position");
1490  PointerGetDatum(splitctx->orig_str),
1491  Int32GetDatum(startpos + 1),
1492  Int32GetDatum(endpos - startpos));
1493  }
1494 }
1495 
1496 /*
1497  * regexp_fixed_prefix - extract fixed prefix, if any, for a regexp
1498  *
1499  * The result is NULL if there is no fixed prefix, else a palloc'd string.
1500  * If it is an exact match, not just a prefix, *exact is returned as true.
1501  */
1502 char *
1503 regexp_fixed_prefix(text *text_re, bool case_insensitive, Oid collation,
1504  bool *exact)
1505 {
1506  char *result;
1507  regex_t *re;
1508  int cflags;
1509  int re_result;
1510  pg_wchar *str;
1511  size_t slen;
1512  size_t maxlen;
1513  char errMsg[100];
1514 
1515  *exact = false; /* default result */
1516 
1517  /* Compile RE */
1518  cflags = REG_ADVANCED;
1519  if (case_insensitive)
1520  cflags |= REG_ICASE;
1521 
1522  re = RE_compile_and_cache(text_re, cflags, collation);
1523 
1524  /* Examine it to see if there's a fixed prefix */
1525  re_result = pg_regprefix(re, &str, &slen);
1526 
1527  switch (re_result)
1528  {
1529  case REG_NOMATCH:
1530  return NULL;
1531 
1532  case REG_PREFIX:
1533  /* continue with wchar conversion */
1534  break;
1535 
1536  case REG_EXACT:
1537  *exact = true;
1538  /* continue with wchar conversion */
1539  break;
1540 
1541  default:
1542  /* re failed??? */
1544  pg_regerror(re_result, re, errMsg, sizeof(errMsg));
1545  ereport(ERROR,
1546  (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
1547  errmsg("regular expression failed: %s", errMsg)));
1548  break;
1549  }
1550 
1551  /* Convert pg_wchar result back to database encoding */
1552  maxlen = pg_database_encoding_max_length() * slen + 1;
1553  result = (char *) palloc(maxlen);
1554  slen = pg_wchar2mb_with_len(str, result, slen);
1555  Assert(slen < maxlen);
1556 
1557  free(str);
1558 
1559  return result;
1560 }
static int num_res
Definition: regexp.c:109
static bool RE_execute(regex_t *re, char *dat, int dat_len, int nmatch, regmatch_t *pmatch)
Definition: regexp.c:309
text * replace_text_regexp(text *src_text, void *regexp, text *replace_text, bool glob)
Definition: varlena.c:4404
#define REG_NLSTOP
Definition: regex.h:109
Datum textregexsubstr(PG_FUNCTION_ARGS)
Definition: regexp.c:564
int errhint(const char *fmt,...)
Definition: elog.c:1069
#define VARDATA_ANY(PTR)
Definition: postgres.h:348
#define VARDATA(PTR)
Definition: postgres.h:302
Datum regexp_matches(PG_FUNCTION_ARGS)
Definition: regexp.c:1012
regex_t cre_re
Definition: regexp.c:106
Datum regexp_matches_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1061
Datum nameregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:440
Datum * elems
Definition: regexp.c:63
Datum similar_to_escape_2(PG_FUNCTION_ARGS)
Definition: regexp.c:906
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:282
#define PointerGetDatum(X)
Definition: postgres.h:556
#define VARHDRSZ
Definition: c.h:562
#define REG_QUOTE
Definition: regex.h:104
int cflags
Definition: regexp.c:48
regoff_t rm_so
Definition: regex.h:85
Datum texticregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:545
bool glob
Definition: regexp.c:49
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
static text * similar_escape_internal(text *pat_text, text *esc_text)
Definition: regexp.c:667
int cre_flags
Definition: regexp.c:104
Datum regexp_split_to_table_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1395
int errcode(int sqlerrcode)
Definition: elog.c:608
bool * nulls
Definition: regexp.c:64
Datum textregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:468
Datum regexp_split_to_array(PG_FUNCTION_ARGS)
Definition: regexp.c:1406
int * match_locs
Definition: regexp.c:60
#define MAX_CACHED_RES
Definition: regexp.c:96
#define REG_PREFIX
Definition: regex.h:162
struct cached_re_str cached_re_str
unsigned int Oid
Definition: postgres_ext.h:31
#define REG_ICASE
Definition: regex.h:106
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:286
int pg_regcomp(regex_t *re, const chr *string, size_t len, int flags, Oid collation)
Definition: regcomp.c:313
char * conv_buf
Definition: regexp.c:66
#define PG_GET_COLLATION()
Definition: fmgr.h:193
char * cre_pat
Definition: regexp.c:102
int pg_regprefix(regex_t *re, chr **string, size_t *slength)
Definition: regprefix.c:46
#define PG_GETARG_TEXT_P_COPY(n)
Definition: fmgr.h:309
regoff_t rm_eo
Definition: regex.h:86
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:303
#define malloc(a)
Definition: header.h:50
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:836
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:288
#define PG_GETARG_TEXT_PP_IF_EXISTS(_n)
Definition: regexp.c:41
size_t re_nsub
Definition: regex.h:58
void pfree(void *pointer)
Definition: mcxt.c:1056
#define REG_OKAY
Definition: regex.h:137
static cached_re_str re_array[MAX_CACHED_RES]
Definition: regexp.c:110
#define ERROR
Definition: elog.h:43
Datum texticregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:531
struct regexp_matches_ctx regexp_matches_ctx
static XLogRecPtr endpos
Definition: pg_receivewal.c:46
bool RE_compile_and_execute(text *text_re, char *dat, int dat_len, int cflags, Oid collation, int nmatch, regmatch_t *pmatch)
Definition: regexp.c:343
Definition: c.h:610
static char * buf
Definition: pg_test_fsync.c:67
#define memmove(d, s, c)
Definition: c.h:1267
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:183
int pg_database_encoding_max_length(void)
Definition: wchar.c:1881
text * orig_str
Definition: regexp.c:55
Datum textregexreplace_noopt(PG_FUNCTION_ARGS)
Definition: regexp.c:623
static regexp_matches_ctx * setup_regexp_matches(text *orig_str, text *pattern, pg_re_flags *flags, Oid collation, bool use_subpatterns, bool ignore_degenerate, bool fetching_unmatched)
Definition: regexp.c:1084
Datum nameicregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:517
Datum similar_escape(PG_FUNCTION_ARGS)
Definition: regexp.c:940
size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
Definition: regerror.c:60
#define REG_NEWLINE
Definition: regex.h:111
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define REG_ADVANCED
Definition: regex.h:103
Datum regexp_split_to_table(PG_FUNCTION_ARGS)
Definition: regexp.c:1342
#define PG_RETURN_ARRAYTYPE_P(x)
Definition: array.h:253
Datum textregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:482
#define ereport(elevel, rest)
Definition: elog.h:141
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5117
unsigned int pg_wchar
Definition: mbprint.c:31
Datum regexp_match(PG_FUNCTION_ARGS)
Definition: regexp.c:966
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:619
#define MaxAllocSize
Definition: memutils.h:40
Datum nameicregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:503
Datum regexp_match_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1002
#define REG_EXTENDED
Definition: regex.h:101
Oid cre_collation
Definition: regexp.c:105
Datum text_substr(PG_FUNCTION_ARGS)
Definition: varlena.c:803
void * palloc0(Size size)
Definition: mcxt.c:980
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:349
uintptr_t Datum
Definition: postgres.h:367
static ArrayType * build_regexp_match_result(regexp_matches_ctx *matchctx)
Definition: regexp.c:1285
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:343
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
Definition: mbutils.c:765
pg_wchar * wide_str
Definition: regexp.c:65
#define free(a)
Definition: header.h:65
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:361
#define Max(x, y)
Definition: c.h:905
#define PG_ARGISNULL(n)
Definition: fmgr.h:204
#define Assert(condition)
Definition: c.h:739
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
#define REG_NLANCH
Definition: regex.h:110
static XLogRecPtr startpos
int pg_mblen(const char *mbstr)
Definition: mbutils.c:802
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1069
regex_t * RE_compile_and_cache(text *text_re, int cflags, Oid collation)
Definition: regexp.c:137
Datum regexp_split_to_array_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1445
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5053
Datum nameregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:454
#define Int32GetDatum(X)
Definition: postgres.h:479
static Datum build_regexp_split_result(regexp_matches_ctx *splitctx)
Definition: regexp.c:1457
e
Definition: preproc-init.c:82
void * user_fctx
Definition: funcapi.h:82
int pg_regexec(regex_t *re, const chr *string, size_t len, size_t search_start, rm_detail_t *details, size_t nmatch, regmatch_t pmatch[], int flags)
Definition: regexec.c:172
#define VARSIZE_ANY_EXHDR(PTR)
Definition: postgres.h:341
#define REG_EXACT
Definition: regex.h:163
void * palloc(Size size)
Definition: mcxt.c:949
char * regexp_fixed_prefix(text *text_re, bool case_insensitive, Oid collation, bool *exact)
Definition: regexp.c:1503
int errmsg(const char *fmt,...)
Definition: elog.c:822
static void parse_re_flags(pg_re_flags *flags, text *opts)
Definition: regexp.c:366
static bool RE_wchar_execute(regex_t *re, pg_wchar *data, int data_len, int start_search, int nmatch, regmatch_t *pmatch)
Definition: regexp.c:266
#define elog(elevel,...)
Definition: elog.h:228
int i
#define REG_EXPANDED
Definition: regex.h:108
#define REG_NOMATCH
Definition: regex.h:138
#define NameStr(name)
Definition: c.h:616
Definition: c.h:556
#define PG_FUNCTION_ARGS
Definition: fmgr.h:188
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:329
Datum textregexreplace(PG_FUNCTION_ARGS)
Definition: regexp.c:640
int pg_wchar2mb_with_len(const pg_wchar *from, char *to, int len)
Definition: mbutils.c:787
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:123
ArrayType * construct_md_array(Datum *elems, bool *nulls, int ndims, int *dims, int *lbs, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3326
void pg_regfree(regex_t *re)
Definition: regfree.c:49
int cre_pat_len
Definition: regexp.c:103
Definition: regex.h:55
Datum similar_to_escape_1(PG_FUNCTION_ARGS)
Definition: regexp.c:922
#define PG_RETURN_NULL()
Definition: fmgr.h:335
struct pg_re_flags pg_re_flags
#define PG_GETARG_NAME(n)
Definition: fmgr.h:273
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:306
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:284