PostgreSQL Source Code: src/backend/utils/adt/regexp.c Source File

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-2025, 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 "regex/regex.h"
35#include "utils/array.h"
36#include "utils/builtins.h"
37#include "utils/memutils.h"
38#include "utils/varlena.h"
39
40 #define PG_GETARG_TEXT_PP_IF_EXISTS(_n) \
41 (PG_NARGS() > (_n) ? PG_GETARG_TEXT_PP(_n) : NULL)
42
43
44/* all the options of interest for regex functions */
45 typedef struct pg_re_flags
46{
47 int cflags; /* compile flags for Spencer's regex code */
48 bool glob; /* do it globally (for each occurrence) */
49 } pg_re_flags;
50
51/* cross-call state for regexp_match and regexp_split functions */
52 typedef struct regexp_matches_ctx
53{
54 text *orig_str; /* data string in original TEXT form */
55 int nmatches; /* number of places where pattern matched */
56 int npatterns; /* number of capturing subpatterns */
57 /* We store start char index and end+1 char index for each match */
58 /* so the number of entries in match_locs is nmatches * npatterns * 2 */
59 int *match_locs; /* 0-based character indexes */
60 int next_match; /* 0-based index of next match to process */
61 /* workspace for build_regexp_match_result() */
62 Datum *elems; /* has npatterns elements */
63 bool *nulls; /* has npatterns elements */
64 pg_wchar *wide_str; /* wide-char version of original string */
65 char *conv_buf; /* conversion buffer, if needed */
66 int conv_bufsiz; /* size thereof */
67 } regexp_matches_ctx;
68
69/*
70 * We cache precompiled regular expressions using a "self organizing list"
71 * structure, in which recently-used items tend to be near the front.
72 * Whenever we use an entry, it's moved up to the front of the list.
73 * Over time, an item's average position corresponds to its frequency of use.
74 *
75 * When we first create an entry, it's inserted at the front of
76 * the array, dropping the entry at the end of the array if necessary to
77 * make room. (This might seem to be weighting the new entry too heavily,
78 * but if we insert new entries further back, we'll be unable to adjust to
79 * a sudden shift in the query mix where we are presented with MAX_CACHED_RES
80 * never-before-seen items used circularly. We ought to be able to handle
81 * that case, so we have to insert at the front.)
82 *
83 * Knuth mentions a variant strategy in which a used item is moved up just
84 * one place in the list. Although he says this uses fewer comparisons on
85 * average, it seems not to adapt very well to the situation where you have
86 * both some reusable patterns and a steady stream of non-reusable patterns.
87 * A reusable pattern that isn't used at least as often as non-reusable
88 * patterns are seen will "fail to keep up" and will drop off the end of the
89 * cache. With move-to-front, a reusable pattern is guaranteed to stay in
90 * the cache as long as it's used at least once in every MAX_CACHED_RES uses.
91 */
92
93/* this is the maximum number of cached regular expressions */
94#ifndef MAX_CACHED_RES
95 #define MAX_CACHED_RES 32
96#endif
97
98/* A parent memory context for regular expressions. */
99 static MemoryContext RegexpCacheMemoryContext;
100
101/* this structure describes one cached regular expression */
102 typedef struct cached_re_str
103{
104 MemoryContext cre_context; /* memory context for this regexp */
105 char *cre_pat; /* original RE (not null terminated!) */
106 int cre_pat_len; /* length of original RE, in bytes */
107 int cre_flags; /* compile flags: extended,icase etc */
108 Oid cre_collation; /* collation to use */
109 regex_t cre_re; /* the compiled regular expression */
110 } cached_re_str;
111
112 static int num_res = 0; /* # of cached re's */
113 static cached_re_str re_array[MAX_CACHED_RES]; /* cached re's */
114
115
116/* Local functions */
117static regexp_matches_ctx *setup_regexp_matches(text *orig_str, text *pattern,
118 pg_re_flags *re_flags,
119 int start_search,
120 Oid collation,
121 bool use_subpatterns,
122 bool ignore_degenerate,
123 bool fetching_unmatched);
124static ArrayType *build_regexp_match_result(regexp_matches_ctx *matchctx);
125static Datum build_regexp_split_result(regexp_matches_ctx *splitctx);
126
127
128/*
129 * RE_compile_and_cache - compile a RE, caching if possible
130 *
131 * Returns regex_t *
132 *
133 * text_re --- the pattern, expressed as a TEXT object
134 * cflags --- compile options for the pattern
135 * collation --- collation to use for LC_CTYPE-dependent behavior
136 *
137 * Pattern is given in the database encoding. We internally convert to
138 * an array of pg_wchar, which is what Spencer's regex package wants.
139 */
140regex_t *
141 RE_compile_and_cache(text *text_re, int cflags, Oid collation)
142{
143 int text_re_len = VARSIZE_ANY_EXHDR(text_re);
144 char *text_re_val = VARDATA_ANY(text_re);
145 pg_wchar *pattern;
146 int pattern_len;
147 int i;
148 int regcomp_result;
149 cached_re_str re_temp;
150 char errMsg[100];
151 MemoryContext oldcontext;
152
153 /*
154 * Look for a match among previously compiled REs. Since the data
155 * structure is self-organizing with most-used entries at the front, our
156 * search strategy can just be to scan from the front.
157 */
158 for (i = 0; i < num_res; i++)
159 {
160 if (re_array[i].cre_pat_len == text_re_len &&
161 re_array[i].cre_flags == cflags &&
162 re_array[i].cre_collation == collation &&
163 memcmp(re_array[i].cre_pat, text_re_val, text_re_len) == 0)
164 {
165 /*
166 * Found a match; move it to front if not there already.
167 */
168 if (i > 0)
169 {
170 re_temp = re_array[i];
171 memmove(&re_array[1], &re_array[0], i * sizeof(cached_re_str));
172 re_array[0] = re_temp;
173 }
174
175 return &re_array[0].cre_re;
176 }
177 }
178
179 /* Set up the cache memory on first go through. */
180 if (unlikely(RegexpCacheMemoryContext == NULL))
181 RegexpCacheMemoryContext =
182 AllocSetContextCreate(TopMemoryContext,
183 "RegexpCacheMemoryContext",
184 ALLOCSET_SMALL_SIZES);
185
186 /*
187 * Couldn't find it, so try to compile the new RE. To avoid leaking
188 * resources on failure, we build into the re_temp local.
189 */
190
191 /* Convert pattern string to wide characters */
192 pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar));
193 pattern_len = pg_mb2wchar_with_len(text_re_val,
194 pattern,
195 text_re_len);
196
197 /*
198 * Make a memory context for this compiled regexp. This is initially a
199 * child of the current memory context, so it will be cleaned up
200 * automatically if compilation is interrupted and throws an ERROR. We'll
201 * re-parent it under the longer lived cache context if we make it to the
202 * bottom of this function.
203 */
204 re_temp.cre_context = AllocSetContextCreate(CurrentMemoryContext,
205 "RegexpMemoryContext",
206 ALLOCSET_SMALL_SIZES);
207 oldcontext = MemoryContextSwitchTo(re_temp.cre_context);
208
209 regcomp_result = pg_regcomp(&re_temp.cre_re,
210 pattern,
211 pattern_len,
212 cflags,
213 collation);
214
215 pfree(pattern);
216
217 if (regcomp_result != REG_OKAY)
218 {
219 /* re didn't compile (no need for pg_regfree, if so) */
220 pg_regerror(regcomp_result, &re_temp.cre_re, errMsg, sizeof(errMsg));
221 ereport(ERROR,
222 (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
223 errmsg("invalid regular expression: %s", errMsg)));
224 }
225
226 /* Copy the pattern into the per-regexp memory context. */
227 re_temp.cre_pat = palloc(text_re_len + 1);
228 memcpy(re_temp.cre_pat, text_re_val, text_re_len);
229
230 /*
231 * NUL-terminate it only for the benefit of the identifier used for the
232 * memory context, visible in the pg_backend_memory_contexts view.
233 */
234 re_temp.cre_pat[text_re_len] = 0;
235 MemoryContextSetIdentifier(re_temp.cre_context, re_temp.cre_pat);
236
237 re_temp.cre_pat_len = text_re_len;
238 re_temp.cre_flags = cflags;
239 re_temp.cre_collation = collation;
240
241 /*
242 * Okay, we have a valid new item in re_temp; insert it into the storage
243 * array. Discard last entry if needed.
244 */
245 if (num_res >= MAX_CACHED_RES)
246 {
247 --num_res;
248 Assert(num_res < MAX_CACHED_RES);
249 /* Delete the memory context holding the regexp and pattern. */
250 MemoryContextDelete(re_array[num_res].cre_context);
251 }
252
253 /* Re-parent the memory context to our long-lived cache context. */
254 MemoryContextSetParent(re_temp.cre_context, RegexpCacheMemoryContext);
255
256 if (num_res > 0)
257 memmove(&re_array[1], &re_array[0], num_res * sizeof(cached_re_str));
258
259 re_array[0] = re_temp;
260 num_res++;
261
262 MemoryContextSwitchTo(oldcontext);
263
264 return &re_array[0].cre_re;
265}
266
267/*
268 * RE_wchar_execute - execute a RE on pg_wchar data
269 *
270 * Returns true on match, false on no match
271 *
272 * re --- the compiled pattern as returned by RE_compile_and_cache
273 * data --- the data to match against (need not be null-terminated)
274 * data_len --- the length of the data string
275 * start_search -- the offset in the data to start searching
276 * nmatch, pmatch --- optional return area for match details
277 *
278 * Data is given as array of pg_wchar which is what Spencer's regex package
279 * wants.
280 */
281static bool
282 RE_wchar_execute(regex_t *re, pg_wchar *data, int data_len,
283 int start_search, int nmatch, regmatch_t *pmatch)
284{
285 int regexec_result;
286 char errMsg[100];
287
288 /* Perform RE match and return result */
289 regexec_result = pg_regexec(re,
290 data,
291 data_len,
292 start_search,
293 NULL, /* no details */
294 nmatch,
295 pmatch,
296 0);
297
298 if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
299 {
300 /* re failed??? */
301 pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
302 ereport(ERROR,
303 (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
304 errmsg("regular expression failed: %s", errMsg)));
305 }
306
307 return (regexec_result == REG_OKAY);
308}
309
310/*
311 * RE_execute - execute a RE
312 *
313 * Returns true on match, false on no match
314 *
315 * re --- the compiled pattern as returned by RE_compile_and_cache
316 * dat --- the data to match against (need not be null-terminated)
317 * dat_len --- the length of the data string
318 * nmatch, pmatch --- optional return area for match details
319 *
320 * Data is given in the database encoding. We internally
321 * convert to array of pg_wchar which is what Spencer's regex package wants.
322 */
323static bool
324 RE_execute(regex_t *re, char *dat, int dat_len,
325 int nmatch, regmatch_t *pmatch)
326{
327 pg_wchar *data;
328 int data_len;
329 bool match;
330
331 /* Convert data string to wide characters */
332 data = (pg_wchar *) palloc((dat_len + 1) * sizeof(pg_wchar));
333 data_len = pg_mb2wchar_with_len(dat, data, dat_len);
334
335 /* Perform RE match and return result */
336 match = RE_wchar_execute(re, data, data_len, 0, nmatch, pmatch);
337
338 pfree(data);
339 return match;
340}
341
342/*
343 * RE_compile_and_execute - compile and execute a RE
344 *
345 * Returns true on match, false on no match
346 *
347 * text_re --- the pattern, expressed as a TEXT object
348 * dat --- the data to match against (need not be null-terminated)
349 * dat_len --- the length of the data string
350 * cflags --- compile options for the pattern
351 * collation --- collation to use for LC_CTYPE-dependent behavior
352 * nmatch, pmatch --- optional return area for match details
353 *
354 * Both pattern and data are given in the database encoding. We internally
355 * convert to array of pg_wchar which is what Spencer's regex package wants.
356 */
357bool
358 RE_compile_and_execute(text *text_re, char *dat, int dat_len,
359 int cflags, Oid collation,
360 int nmatch, regmatch_t *pmatch)
361{
362 regex_t *re;
363
364 /* Use REG_NOSUB if caller does not want sub-match details */
365 if (nmatch < 2)
366 cflags |= REG_NOSUB;
367
368 /* Compile RE */
369 re = RE_compile_and_cache(text_re, cflags, collation);
370
371 return RE_execute(re, dat, dat_len, nmatch, pmatch);
372}
373
374
375/*
376 * parse_re_flags - parse the options argument of regexp_match and friends
377 *
378 * flags --- output argument, filled with desired options
379 * opts --- TEXT object, or NULL for defaults
380 *
381 * This accepts all the options allowed by any of the callers; callers that
382 * don't want some have to reject them after the fact.
383 */
384static void
385 parse_re_flags(pg_re_flags *flags, text *opts)
386{
387 /* regex flavor is always folded into the compile flags */
388 flags->cflags = REG_ADVANCED;
389 flags->glob = false;
390
391 if (opts)
392 {
393 char *opt_p = VARDATA_ANY(opts);
394 int opt_len = VARSIZE_ANY_EXHDR(opts);
395 int i;
396
397 for (i = 0; i < opt_len; i++)
398 {
399 switch (opt_p[i])
400 {
401 case 'g':
402 flags->glob = true;
403 break;
404 case 'b': /* BREs (but why???) */
405 flags->cflags &= ~(REG_ADVANCED | REG_EXTENDED | REG_QUOTE);
406 break;
407 case 'c': /* case sensitive */
408 flags->cflags &= ~REG_ICASE;
409 break;
410 case 'e': /* plain EREs */
411 flags->cflags |= REG_EXTENDED;
412 flags->cflags &= ~(REG_ADVANCED | REG_QUOTE);
413 break;
414 case 'i': /* case insensitive */
415 flags->cflags |= REG_ICASE;
416 break;
417 case 'm': /* Perloid synonym for n */
418 case 'n': /* \n affects ^ $ . [^ */
419 flags->cflags |= REG_NEWLINE;
420 break;
421 case 'p': /* ~Perl, \n affects . [^ */
422 flags->cflags |= REG_NLSTOP;
423 flags->cflags &= ~REG_NLANCH;
424 break;
425 case 'q': /* literal string */
426 flags->cflags |= REG_QUOTE;
427 flags->cflags &= ~(REG_ADVANCED | REG_EXTENDED);
428 break;
429 case 's': /* single line, \n ordinary */
430 flags->cflags &= ~REG_NEWLINE;
431 break;
432 case 't': /* tight syntax */
433 flags->cflags &= ~REG_EXPANDED;
434 break;
435 case 'w': /* weird, \n affects ^ $ only */
436 flags->cflags &= ~REG_NLSTOP;
437 flags->cflags |= REG_NLANCH;
438 break;
439 case 'x': /* expanded syntax */
440 flags->cflags |= REG_EXPANDED;
441 break;
442 default:
443 ereport(ERROR,
444 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
445 errmsg("invalid regular expression option: \"%.*s\"",
446 pg_mblen(opt_p + i), opt_p + i)));
447 break;
448 }
449 }
450 }
451}
452
453
454/*
455 * interface routines called by the function manager
456 */
457
458Datum
459 nameregexeq(PG_FUNCTION_ARGS)
460{
461 Name n = PG_GETARG_NAME(0);
462 text *p = PG_GETARG_TEXT_PP(1);
463
464 PG_RETURN_BOOL(RE_compile_and_execute(p,
465 NameStr(*n),
466 strlen(NameStr(*n)),
467 REG_ADVANCED,
468 PG_GET_COLLATION(),
469 0, NULL));
470}
471
472Datum
473 nameregexne(PG_FUNCTION_ARGS)
474{
475 Name n = PG_GETARG_NAME(0);
476 text *p = PG_GETARG_TEXT_PP(1);
477
478 PG_RETURN_BOOL(!RE_compile_and_execute(p,
479 NameStr(*n),
480 strlen(NameStr(*n)),
481 REG_ADVANCED,
482 PG_GET_COLLATION(),
483 0, NULL));
484}
485
486Datum
487 textregexeq(PG_FUNCTION_ARGS)
488{
489 text *s = PG_GETARG_TEXT_PP(0);
490 text *p = PG_GETARG_TEXT_PP(1);
491
492 PG_RETURN_BOOL(RE_compile_and_execute(p,
493 VARDATA_ANY(s),
494 VARSIZE_ANY_EXHDR(s),
495 REG_ADVANCED,
496 PG_GET_COLLATION(),
497 0, NULL));
498}
499
500Datum
501 textregexne(PG_FUNCTION_ARGS)
502{
503 text *s = PG_GETARG_TEXT_PP(0);
504 text *p = PG_GETARG_TEXT_PP(1);
505
506 PG_RETURN_BOOL(!RE_compile_and_execute(p,
507 VARDATA_ANY(s),
508 VARSIZE_ANY_EXHDR(s),
509 REG_ADVANCED,
510 PG_GET_COLLATION(),
511 0, NULL));
512}
513
514
515/*
516 * routines that use the regexp stuff, but ignore the case.
517 * for this, we use the REG_ICASE flag to pg_regcomp
518 */
519
520
521Datum
522 nameicregexeq(PG_FUNCTION_ARGS)
523{
524 Name n = PG_GETARG_NAME(0);
525 text *p = PG_GETARG_TEXT_PP(1);
526
527 PG_RETURN_BOOL(RE_compile_and_execute(p,
528 NameStr(*n),
529 strlen(NameStr(*n)),
530 REG_ADVANCED | REG_ICASE,
531 PG_GET_COLLATION(),
532 0, NULL));
533}
534
535Datum
536 nameicregexne(PG_FUNCTION_ARGS)
537{
538 Name n = PG_GETARG_NAME(0);
539 text *p = PG_GETARG_TEXT_PP(1);
540
541 PG_RETURN_BOOL(!RE_compile_and_execute(p,
542 NameStr(*n),
543 strlen(NameStr(*n)),
544 REG_ADVANCED | REG_ICASE,
545 PG_GET_COLLATION(),
546 0, NULL));
547}
548
549Datum
550 texticregexeq(PG_FUNCTION_ARGS)
551{
552 text *s = PG_GETARG_TEXT_PP(0);
553 text *p = PG_GETARG_TEXT_PP(1);
554
555 PG_RETURN_BOOL(RE_compile_and_execute(p,
556 VARDATA_ANY(s),
557 VARSIZE_ANY_EXHDR(s),
558 REG_ADVANCED | REG_ICASE,
559 PG_GET_COLLATION(),
560 0, NULL));
561}
562
563Datum
564 texticregexne(PG_FUNCTION_ARGS)
565{
566 text *s = PG_GETARG_TEXT_PP(0);
567 text *p = PG_GETARG_TEXT_PP(1);
568
569 PG_RETURN_BOOL(!RE_compile_and_execute(p,
570 VARDATA_ANY(s),
571 VARSIZE_ANY_EXHDR(s),
572 REG_ADVANCED | REG_ICASE,
573 PG_GET_COLLATION(),
574 0, NULL));
575}
576
577
578/*
579 * textregexsubstr()
580 * Return a substring matched by a regular expression.
581 */
582Datum
583 textregexsubstr(PG_FUNCTION_ARGS)
584{
585 text *s = PG_GETARG_TEXT_PP(0);
586 text *p = PG_GETARG_TEXT_PP(1);
587 regex_t *re;
588 regmatch_t pmatch[2];
589 int so,
590 eo;
591
592 /* Compile RE */
593 re = RE_compile_and_cache(p, REG_ADVANCED, PG_GET_COLLATION());
594
595 /*
596 * We pass two regmatch_t structs to get info about the overall match and
597 * the match for the first parenthesized subexpression (if any). If there
598 * is a parenthesized subexpression, we return what it matched; else
599 * return what the whole regexp matched.
600 */
601 if (!RE_execute(re,
602 VARDATA_ANY(s), VARSIZE_ANY_EXHDR(s),
603 2, pmatch))
604 PG_RETURN_NULL(); /* definitely no match */
605
606 if (re->re_nsub > 0)
607 {
608 /* has parenthesized subexpressions, use the first one */
609 so = pmatch[1].rm_so;
610 eo = pmatch[1].rm_eo;
611 }
612 else
613 {
614 /* no parenthesized subexpression, use whole match */
615 so = pmatch[0].rm_so;
616 eo = pmatch[0].rm_eo;
617 }
618
619 /*
620 * It is possible to have a match to the whole pattern but no match for a
621 * subexpression; for example 'foo(bar)?' is considered to match 'foo' but
622 * there is no subexpression match. So this extra test for match failure
623 * is not redundant.
624 */
625 if (so < 0 || eo < 0)
626 PG_RETURN_NULL();
627
628 return DirectFunctionCall3(text_substr,
629 PointerGetDatum(s),
630 Int32GetDatum(so + 1),
631 Int32GetDatum(eo - so));
632}
633
634/*
635 * textregexreplace_noopt()
636 * Return a string matched by a regular expression, with replacement.
637 *
638 * This version doesn't have an option argument: we default to case
639 * sensitive match, replace the first instance only.
640 */
641Datum
642 textregexreplace_noopt(PG_FUNCTION_ARGS)
643{
644 text *s = PG_GETARG_TEXT_PP(0);
645 text *p = PG_GETARG_TEXT_PP(1);
646 text *r = PG_GETARG_TEXT_PP(2);
647
648 PG_RETURN_TEXT_P(replace_text_regexp(s, p, r,
649 REG_ADVANCED, PG_GET_COLLATION(),
650 0, 1));
651}
652
653/*
654 * textregexreplace()
655 * Return a string matched by a regular expression, with replacement.
656 */
657Datum
658 textregexreplace(PG_FUNCTION_ARGS)
659{
660 text *s = PG_GETARG_TEXT_PP(0);
661 text *p = PG_GETARG_TEXT_PP(1);
662 text *r = PG_GETARG_TEXT_PP(2);
663 text *opt = PG_GETARG_TEXT_PP(3);
664 pg_re_flags flags;
665
666 /*
667 * regexp_replace() with four arguments will be preferentially resolved as
668 * this form when the fourth argument is of type UNKNOWN. However, the
669 * user might have intended to call textregexreplace_extended_no_n. If we
670 * see flags that look like an integer, emit the same error that
671 * parse_re_flags would, but add a HINT about how to fix it.
672 */
673 if (VARSIZE_ANY_EXHDR(opt) > 0)
674 {
675 char *opt_p = VARDATA_ANY(opt);
676
677 if (*opt_p >= '0' && *opt_p <= '9')
678 ereport(ERROR,
679 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
680 errmsg("invalid regular expression option: \"%.*s\"",
681 pg_mblen(opt_p), opt_p),
682 errhint("If you meant to use regexp_replace() with a start parameter, cast the fourth argument to integer explicitly.")));
683 }
684
685 parse_re_flags(&flags, opt);
686
687 PG_RETURN_TEXT_P(replace_text_regexp(s, p, r,
688 flags.cflags, PG_GET_COLLATION(),
689 0, flags.glob ? 0 : 1));
690}
691
692/*
693 * textregexreplace_extended()
694 * Return a string matched by a regular expression, with replacement.
695 * Extends textregexreplace by allowing a start position and the
696 * choice of the occurrence to replace (0 means all occurrences).
697 */
698Datum
699 textregexreplace_extended(PG_FUNCTION_ARGS)
700{
701 text *s = PG_GETARG_TEXT_PP(0);
702 text *p = PG_GETARG_TEXT_PP(1);
703 text *r = PG_GETARG_TEXT_PP(2);
704 int start = 1;
705 int n = 1;
706 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(5);
707 pg_re_flags re_flags;
708
709 /* Collect optional parameters */
710 if (PG_NARGS() > 3)
711 {
712 start = PG_GETARG_INT32(3);
713 if (start <= 0)
714 ereport(ERROR,
715 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
716 errmsg("invalid value for parameter \"%s\": %d",
717 "start", start)));
718 }
719 if (PG_NARGS() > 4)
720 {
721 n = PG_GETARG_INT32(4);
722 if (n < 0)
723 ereport(ERROR,
724 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
725 errmsg("invalid value for parameter \"%s\": %d",
726 "n", n)));
727 }
728
729 /* Determine options */
730 parse_re_flags(&re_flags, flags);
731
732 /* If N was not specified, deduce it from the 'g' flag */
733 if (PG_NARGS() <= 4)
734 n = re_flags.glob ? 0 : 1;
735
736 /* Do the replacement(s) */
737 PG_RETURN_TEXT_P(replace_text_regexp(s, p, r,
738 re_flags.cflags, PG_GET_COLLATION(),
739 start - 1, n));
740}
741
742/* This is separate to keep the opr_sanity regression test from complaining */
743Datum
744 textregexreplace_extended_no_n(PG_FUNCTION_ARGS)
745{
746 return textregexreplace_extended(fcinfo);
747}
748
749/* This is separate to keep the opr_sanity regression test from complaining */
750Datum
751 textregexreplace_extended_no_flags(PG_FUNCTION_ARGS)
752{
753 return textregexreplace_extended(fcinfo);
754}
755
756/*
757 * similar_to_escape(), similar_escape()
758 *
759 * Convert a SQL "SIMILAR TO" regexp pattern to POSIX style, so it can be
760 * used by our regexp engine.
761 *
762 * similar_escape_internal() is the common workhorse for three SQL-exposed
763 * functions. esc_text can be passed as NULL to select the default escape
764 * (which is '\'), or as an empty string to select no escape character.
765 */
766static text *
767 similar_escape_internal(text *pat_text, text *esc_text)
768{
769 text *result;
770 char *p,
771 *e,
772 *r;
773 int plen,
774 elen;
775 bool afterescape = false;
776 int nquotes = 0;
777 int bracket_depth = 0; /* square bracket nesting level */
778 int charclass_pos = 0; /* position inside a character class */
779
780 p = VARDATA_ANY(pat_text);
781 plen = VARSIZE_ANY_EXHDR(pat_text);
782 if (esc_text == NULL)
783 {
784 /* No ESCAPE clause provided; default to backslash as escape */
785 e = "\\";
786 elen = 1;
787 }
788 else
789 {
790 e = VARDATA_ANY(esc_text);
791 elen = VARSIZE_ANY_EXHDR(esc_text);
792 if (elen == 0)
793 e = NULL; /* no escape character */
794 else if (elen > 1)
795 {
796 int escape_mblen = pg_mbstrlen_with_len(e, elen);
797
798 if (escape_mblen > 1)
799 ereport(ERROR,
800 (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
801 errmsg("invalid escape string"),
802 errhint("Escape string must be empty or one character.")));
803 }
804 }
805
806 /*----------
807 * We surround the transformed input string with
808 * ^(?: ... )$
809 * which requires some explanation. We need "^" and "$" to force
810 * the pattern to match the entire input string as per the SQL spec.
811 * The "(?:" and ")" are a non-capturing set of parens; we have to have
812 * parens in case the string contains "|", else the "^" and "$" will
813 * be bound into the first and last alternatives which is not what we
814 * want, and the parens must be non capturing because we don't want them
815 * to count when selecting output for SUBSTRING.
816 *
817 * When the pattern is divided into three parts by escape-double-quotes,
818 * what we emit is
819 * ^(?:part1){1,1}?(part2){1,1}(?:part3)$
820 * which requires even more explanation. The "{1,1}?" on part1 makes it
821 * non-greedy so that it will match the smallest possible amount of text
822 * not the largest, as required by SQL. The plain parens around part2
823 * are capturing parens so that that part is what controls the result of
824 * SUBSTRING. The "{1,1}" forces part2 to be greedy, so that it matches
825 * the largest possible amount of text; hence part3 must match the
826 * smallest amount of text, as required by SQL. We don't need an explicit
827 * greediness marker on part3. Note that this also confines the effects
828 * of any "|" characters to the respective part, which is what we want.
829 *
830 * The SQL spec says that SUBSTRING's pattern must contain exactly two
831 * escape-double-quotes, but we only complain if there's more than two.
832 * With none, we act as though part1 and part3 are empty; with one, we
833 * act as though part3 is empty. Both behaviors fall out of omitting
834 * the relevant part separators in the above expansion. If the result
835 * of this function is used in a plain regexp match (SIMILAR TO), the
836 * escape-double-quotes have no effect on the match behavior.
837 *
838 * While we don't fully validate character classes (bracket expressions),
839 * we do need to parse them well enough to know where they end.
840 * "charclass_pos" tracks where we are in a character class.
841 * Its value is uninteresting when bracket_depth is 0.
842 * But when bracket_depth > 0, it will be
843 * 1: right after the opening '[' (a following '^' will negate
844 * the class, while ']' is a literal character)
845 * 2: right after a '^' after the opening '[' (']' is still a literal
846 * character)
847 * 3 or more: further inside the character class (']' ends the class)
848 *----------
849 */
850
851 /*
852 * We need room for the prefix/postfix and part separators, plus as many
853 * as 3 output bytes per input byte; since the input is at most 1GB this
854 * can't overflow size_t.
855 */
856 result = (text *) palloc(VARHDRSZ + 23 + 3 * (size_t) plen);
857 r = VARDATA(result);
858
859 *r++ = '^';
860 *r++ = '(';
861 *r++ = '?';
862 *r++ = ':';
863
864 while (plen > 0)
865 {
866 char pchar = *p;
867
868 /*
869 * If both the escape character and the current character from the
870 * pattern are multi-byte, we need to take the slow path.
871 *
872 * But if one of them is single-byte, we can process the pattern one
873 * byte at a time, ignoring multi-byte characters. (This works
874 * because all server-encodings have the property that a valid
875 * multi-byte character representation cannot contain the
876 * representation of a valid single-byte character.)
877 */
878
879 if (elen > 1)
880 {
881 int mblen = pg_mblen(p);
882
883 if (mblen > 1)
884 {
885 /* slow, multi-byte path */
886 if (afterescape)
887 {
888 *r++ = '\\';
889 memcpy(r, p, mblen);
890 r += mblen;
891 afterescape = false;
892 }
893 else if (e && elen == mblen && memcmp(e, p, mblen) == 0)
894 {
895 /* SQL escape character; do not send to output */
896 afterescape = true;
897 }
898 else
899 {
900 /*
901 * We know it's a multi-byte character, so we don't need
902 * to do all the comparisons to single-byte characters
903 * that we do below.
904 */
905 memcpy(r, p, mblen);
906 r += mblen;
907 }
908
909 p += mblen;
910 plen -= mblen;
911
912 continue;
913 }
914 }
915
916 /* fast path */
917 if (afterescape)
918 {
919 if (pchar == '"' && bracket_depth < 1) /* escape-double-quote? */
920 {
921 /* emit appropriate part separator, per notes above */
922 if (nquotes == 0)
923 {
924 *r++ = ')';
925 *r++ = '{';
926 *r++ = '1';
927 *r++ = ',';
928 *r++ = '1';
929 *r++ = '}';
930 *r++ = '?';
931 *r++ = '(';
932 }
933 else if (nquotes == 1)
934 {
935 *r++ = ')';
936 *r++ = '{';
937 *r++ = '1';
938 *r++ = ',';
939 *r++ = '1';
940 *r++ = '}';
941 *r++ = '(';
942 *r++ = '?';
943 *r++ = ':';
944 }
945 else
946 ereport(ERROR,
947 (errcode(ERRCODE_INVALID_USE_OF_ESCAPE_CHARACTER),
948 errmsg("SQL regular expression may not contain more than two escape-double-quote separators")));
949 nquotes++;
950 }
951 else
952 {
953 /*
954 * We allow any character at all to be escaped; notably, this
955 * allows access to POSIX character-class escapes such as
956 * "\d". The SQL spec is considerably more restrictive.
957 */
958 *r++ = '\\';
959 *r++ = pchar;
960
961 /*
962 * If we encounter an escaped character in a character class,
963 * we are no longer at the beginning.
964 */
965 charclass_pos = 3;
966 }
967 afterescape = false;
968 }
969 else if (e && pchar == *e)
970 {
971 /* SQL escape character; do not send to output */
972 afterescape = true;
973 }
974 else if (bracket_depth > 0)
975 {
976 /* inside a character class */
977 if (pchar == '\\')
978 {
979 /*
980 * If we're here, backslash is not the SQL escape character,
981 * so treat it as a literal class element, which requires
982 * doubling it. (This matches our behavior for backslashes
983 * outside character classes.)
984 */
985 *r++ = '\\';
986 }
987 *r++ = pchar;
988
989 /* parse the character class well enough to identify ending ']' */
990 if (pchar == ']' && charclass_pos > 2)
991 {
992 /* found the real end of a bracket pair */
993 bracket_depth--;
994 /* don't reset charclass_pos, this may be an inner bracket */
995 }
996 else if (pchar == '[')
997 {
998 /* start of a nested bracket pair */
999 bracket_depth++;
1000
1001 /*
1002 * We are no longer at the beginning of a character class.
1003 * (The nested bracket pair is a collating element, not a
1004 * character class in its own right.)
1005 */
1006 charclass_pos = 3;
1007 }
1008 else if (pchar == '^')
1009 {
1010 /*
1011 * A caret right after the opening bracket negates the
1012 * character class. In that case, the following will
1013 * increment charclass_pos from 1 to 2, so that a following
1014 * ']' is still a literal character and does not end the
1015 * character class. If we are further inside a character
1016 * class, charclass_pos might get incremented past 3, which is
1017 * fine.
1018 */
1019 charclass_pos++;
1020 }
1021 else
1022 {
1023 /*
1024 * Anything else (including a backslash or leading ']') is an
1025 * element of the character class, so we are no longer at the
1026 * beginning of the class.
1027 */
1028 charclass_pos = 3;
1029 }
1030 }
1031 else if (pchar == '[')
1032 {
1033 /* start of a character class */
1034 *r++ = pchar;
1035 bracket_depth = 1;
1036 charclass_pos = 1;
1037 }
1038 else if (pchar == '%')
1039 {
1040 *r++ = '.';
1041 *r++ = '*';
1042 }
1043 else if (pchar == '_')
1044 *r++ = '.';
1045 else if (pchar == '(')
1046 {
1047 /* convert to non-capturing parenthesis */
1048 *r++ = '(';
1049 *r++ = '?';
1050 *r++ = ':';
1051 }
1052 else if (pchar == '\\' || pchar == '.' ||
1053 pchar == '^' || pchar == '$')
1054 {
1055 *r++ = '\\';
1056 *r++ = pchar;
1057 }
1058 else
1059 *r++ = pchar;
1060 p++, plen--;
1061 }
1062
1063 *r++ = ')';
1064 *r++ = '$';
1065
1066 SET_VARSIZE(result, r - ((char *) result));
1067
1068 return result;
1069}
1070
1071/*
1072 * similar_to_escape(pattern, escape)
1073 */
1074Datum
1075 similar_to_escape_2(PG_FUNCTION_ARGS)
1076{
1077 text *pat_text = PG_GETARG_TEXT_PP(0);
1078 text *esc_text = PG_GETARG_TEXT_PP(1);
1079 text *result;
1080
1081 result = similar_escape_internal(pat_text, esc_text);
1082
1083 PG_RETURN_TEXT_P(result);
1084}
1085
1086/*
1087 * similar_to_escape(pattern)
1088 * Inserts a default escape character.
1089 */
1090Datum
1091 similar_to_escape_1(PG_FUNCTION_ARGS)
1092{
1093 text *pat_text = PG_GETARG_TEXT_PP(0);
1094 text *result;
1095
1096 result = similar_escape_internal(pat_text, NULL);
1097
1098 PG_RETURN_TEXT_P(result);
1099}
1100
1101/*
1102 * similar_escape(pattern, escape)
1103 *
1104 * Legacy function for compatibility with views stored using the
1105 * pre-v13 expansion of SIMILAR TO. Unlike the above functions, this
1106 * is non-strict, which leads to not-per-spec handling of "ESCAPE NULL".
1107 */
1108Datum
1109 similar_escape(PG_FUNCTION_ARGS)
1110{
1111 text *pat_text;
1112 text *esc_text;
1113 text *result;
1114
1115 /* This function is not strict, so must test explicitly */
1116 if (PG_ARGISNULL(0))
1117 PG_RETURN_NULL();
1118 pat_text = PG_GETARG_TEXT_PP(0);
1119
1120 if (PG_ARGISNULL(1))
1121 esc_text = NULL; /* use default escape character */
1122 else
1123 esc_text = PG_GETARG_TEXT_PP(1);
1124
1125 result = similar_escape_internal(pat_text, esc_text);
1126
1127 PG_RETURN_TEXT_P(result);
1128}
1129
1130/*
1131 * regexp_count()
1132 * Return the number of matches of a pattern within a string.
1133 */
1134Datum
1135 regexp_count(PG_FUNCTION_ARGS)
1136{
1137 text *str = PG_GETARG_TEXT_PP(0);
1138 text *pattern = PG_GETARG_TEXT_PP(1);
1139 int start = 1;
1140 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(3);
1141 pg_re_flags re_flags;
1142 regexp_matches_ctx *matchctx;
1143
1144 /* Collect optional parameters */
1145 if (PG_NARGS() > 2)
1146 {
1147 start = PG_GETARG_INT32(2);
1148 if (start <= 0)
1149 ereport(ERROR,
1150 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1151 errmsg("invalid value for parameter \"%s\": %d",
1152 "start", start)));
1153 }
1154
1155 /* Determine options */
1156 parse_re_flags(&re_flags, flags);
1157 /* User mustn't specify 'g' */
1158 if (re_flags.glob)
1159 ereport(ERROR,
1160 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1161 /* translator: %s is a SQL function name */
1162 errmsg("%s does not support the \"global\" option",
1163 "regexp_count()")));
1164 /* But we find all the matches anyway */
1165 re_flags.glob = true;
1166
1167 /* Do the matching */
1168 matchctx = setup_regexp_matches(str, pattern, &re_flags, start - 1,
1169 PG_GET_COLLATION(),
1170 false, /* can ignore subexprs */
1171 false, false);
1172
1173 PG_RETURN_INT32(matchctx->nmatches);
1174}
1175
1176/* This is separate to keep the opr_sanity regression test from complaining */
1177Datum
1178 regexp_count_no_start(PG_FUNCTION_ARGS)
1179{
1180 return regexp_count(fcinfo);
1181}
1182
1183/* This is separate to keep the opr_sanity regression test from complaining */
1184Datum
1185 regexp_count_no_flags(PG_FUNCTION_ARGS)
1186{
1187 return regexp_count(fcinfo);
1188}
1189
1190/*
1191 * regexp_instr()
1192 * Return the match's position within the string
1193 */
1194Datum
1195 regexp_instr(PG_FUNCTION_ARGS)
1196{
1197 text *str = PG_GETARG_TEXT_PP(0);
1198 text *pattern = PG_GETARG_TEXT_PP(1);
1199 int start = 1;
1200 int n = 1;
1201 int endoption = 0;
1202 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(5);
1203 int subexpr = 0;
1204 int pos;
1205 pg_re_flags re_flags;
1206 regexp_matches_ctx *matchctx;
1207
1208 /* Collect optional parameters */
1209 if (PG_NARGS() > 2)
1210 {
1211 start = PG_GETARG_INT32(2);
1212 if (start <= 0)
1213 ereport(ERROR,
1214 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1215 errmsg("invalid value for parameter \"%s\": %d",
1216 "start", start)));
1217 }
1218 if (PG_NARGS() > 3)
1219 {
1220 n = PG_GETARG_INT32(3);
1221 if (n <= 0)
1222 ereport(ERROR,
1223 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1224 errmsg("invalid value for parameter \"%s\": %d",
1225 "n", n)));
1226 }
1227 if (PG_NARGS() > 4)
1228 {
1229 endoption = PG_GETARG_INT32(4);
1230 if (endoption != 0 && endoption != 1)
1231 ereport(ERROR,
1232 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1233 errmsg("invalid value for parameter \"%s\": %d",
1234 "endoption", endoption)));
1235 }
1236 if (PG_NARGS() > 6)
1237 {
1238 subexpr = PG_GETARG_INT32(6);
1239 if (subexpr < 0)
1240 ereport(ERROR,
1241 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1242 errmsg("invalid value for parameter \"%s\": %d",
1243 "subexpr", subexpr)));
1244 }
1245
1246 /* Determine options */
1247 parse_re_flags(&re_flags, flags);
1248 /* User mustn't specify 'g' */
1249 if (re_flags.glob)
1250 ereport(ERROR,
1251 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1252 /* translator: %s is a SQL function name */
1253 errmsg("%s does not support the \"global\" option",
1254 "regexp_instr()")));
1255 /* But we find all the matches anyway */
1256 re_flags.glob = true;
1257
1258 /* Do the matching */
1259 matchctx = setup_regexp_matches(str, pattern, &re_flags, start - 1,
1260 PG_GET_COLLATION(),
1261 (subexpr > 0), /* need submatches? */
1262 false, false);
1263
1264 /* When n exceeds matches return 0 (includes case of no matches) */
1265 if (n > matchctx->nmatches)
1266 PG_RETURN_INT32(0);
1267
1268 /* When subexpr exceeds number of subexpressions return 0 */
1269 if (subexpr > matchctx->npatterns)
1270 PG_RETURN_INT32(0);
1271
1272 /* Select the appropriate match position to return */
1273 pos = (n - 1) * matchctx->npatterns;
1274 if (subexpr > 0)
1275 pos += subexpr - 1;
1276 pos *= 2;
1277 if (endoption == 1)
1278 pos += 1;
1279
1280 if (matchctx->match_locs[pos] >= 0)
1281 PG_RETURN_INT32(matchctx->match_locs[pos] + 1);
1282 else
1283 PG_RETURN_INT32(0); /* position not identifiable */
1284}
1285
1286/* This is separate to keep the opr_sanity regression test from complaining */
1287Datum
1288 regexp_instr_no_start(PG_FUNCTION_ARGS)
1289{
1290 return regexp_instr(fcinfo);
1291}
1292
1293/* This is separate to keep the opr_sanity regression test from complaining */
1294Datum
1295 regexp_instr_no_n(PG_FUNCTION_ARGS)
1296{
1297 return regexp_instr(fcinfo);
1298}
1299
1300/* This is separate to keep the opr_sanity regression test from complaining */
1301Datum
1302 regexp_instr_no_endoption(PG_FUNCTION_ARGS)
1303{
1304 return regexp_instr(fcinfo);
1305}
1306
1307/* This is separate to keep the opr_sanity regression test from complaining */
1308Datum
1309 regexp_instr_no_flags(PG_FUNCTION_ARGS)
1310{
1311 return regexp_instr(fcinfo);
1312}
1313
1314/* This is separate to keep the opr_sanity regression test from complaining */
1315Datum
1316 regexp_instr_no_subexpr(PG_FUNCTION_ARGS)
1317{
1318 return regexp_instr(fcinfo);
1319}
1320
1321/*
1322 * regexp_like()
1323 * Test for a pattern match within a string.
1324 */
1325Datum
1326 regexp_like(PG_FUNCTION_ARGS)
1327{
1328 text *str = PG_GETARG_TEXT_PP(0);
1329 text *pattern = PG_GETARG_TEXT_PP(1);
1330 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1331 pg_re_flags re_flags;
1332
1333 /* Determine options */
1334 parse_re_flags(&re_flags, flags);
1335 /* User mustn't specify 'g' */
1336 if (re_flags.glob)
1337 ereport(ERROR,
1338 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1339 /* translator: %s is a SQL function name */
1340 errmsg("%s does not support the \"global\" option",
1341 "regexp_like()")));
1342
1343 /* Otherwise it's like textregexeq/texticregexeq */
1344 PG_RETURN_BOOL(RE_compile_and_execute(pattern,
1345 VARDATA_ANY(str),
1346 VARSIZE_ANY_EXHDR(str),
1347 re_flags.cflags,
1348 PG_GET_COLLATION(),
1349 0, NULL));
1350}
1351
1352/* This is separate to keep the opr_sanity regression test from complaining */
1353Datum
1354 regexp_like_no_flags(PG_FUNCTION_ARGS)
1355{
1356 return regexp_like(fcinfo);
1357}
1358
1359/*
1360 * regexp_match()
1361 * Return the first substring(s) matching a pattern within a string.
1362 */
1363Datum
1364 regexp_match(PG_FUNCTION_ARGS)
1365{
1366 text *orig_str = PG_GETARG_TEXT_PP(0);
1367 text *pattern = PG_GETARG_TEXT_PP(1);
1368 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1369 pg_re_flags re_flags;
1370 regexp_matches_ctx *matchctx;
1371
1372 /* Determine options */
1373 parse_re_flags(&re_flags, flags);
1374 /* User mustn't specify 'g' */
1375 if (re_flags.glob)
1376 ereport(ERROR,
1377 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1378 /* translator: %s is a SQL function name */
1379 errmsg("%s does not support the \"global\" option",
1380 "regexp_match()"),
1381 errhint("Use the regexp_matches function instead.")));
1382
1383 matchctx = setup_regexp_matches(orig_str, pattern, &re_flags, 0,
1384 PG_GET_COLLATION(), true, false, false);
1385
1386 if (matchctx->nmatches == 0)
1387 PG_RETURN_NULL();
1388
1389 Assert(matchctx->nmatches == 1);
1390
1391 /* Create workspace that build_regexp_match_result needs */
1392 matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
1393 matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
1394
1395 PG_RETURN_DATUM(PointerGetDatum(build_regexp_match_result(matchctx)));
1396}
1397
1398/* This is separate to keep the opr_sanity regression test from complaining */
1399Datum
1400 regexp_match_no_flags(PG_FUNCTION_ARGS)
1401{
1402 return regexp_match(fcinfo);
1403}
1404
1405/*
1406 * regexp_matches()
1407 * Return a table of all matches of a pattern within a string.
1408 */
1409Datum
1410 regexp_matches(PG_FUNCTION_ARGS)
1411{
1412 FuncCallContext *funcctx;
1413 regexp_matches_ctx *matchctx;
1414
1415 if (SRF_IS_FIRSTCALL())
1416 {
1417 text *pattern = PG_GETARG_TEXT_PP(1);
1418 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1419 pg_re_flags re_flags;
1420 MemoryContext oldcontext;
1421
1422 funcctx = SRF_FIRSTCALL_INIT();
1423 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1424
1425 /* Determine options */
1426 parse_re_flags(&re_flags, flags);
1427
1428 /* be sure to copy the input string into the multi-call ctx */
1429 matchctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
1430 &re_flags, 0,
1431 PG_GET_COLLATION(),
1432 true, false, false);
1433
1434 /* Pre-create workspace that build_regexp_match_result needs */
1435 matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
1436 matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
1437
1438 MemoryContextSwitchTo(oldcontext);
1439 funcctx->user_fctx = matchctx;
1440 }
1441
1442 funcctx = SRF_PERCALL_SETUP();
1443 matchctx = (regexp_matches_ctx *) funcctx->user_fctx;
1444
1445 if (matchctx->next_match < matchctx->nmatches)
1446 {
1447 ArrayType *result_ary;
1448
1449 result_ary = build_regexp_match_result(matchctx);
1450 matchctx->next_match++;
1451 SRF_RETURN_NEXT(funcctx, PointerGetDatum(result_ary));
1452 }
1453
1454 SRF_RETURN_DONE(funcctx);
1455}
1456
1457/* This is separate to keep the opr_sanity regression test from complaining */
1458Datum
1459 regexp_matches_no_flags(PG_FUNCTION_ARGS)
1460{
1461 return regexp_matches(fcinfo);
1462}
1463
1464/*
1465 * setup_regexp_matches --- do the initial matching for regexp_match,
1466 * regexp_split, and related functions
1467 *
1468 * To avoid having to re-find the compiled pattern on each call, we do
1469 * all the matching in one swoop. The returned regexp_matches_ctx contains
1470 * the locations of all the substrings matching the pattern.
1471 *
1472 * start_search: the character (not byte) offset in orig_str at which to
1473 * begin the search. Returned positions are relative to orig_str anyway.
1474 * use_subpatterns: collect data about matches to parenthesized subexpressions.
1475 * ignore_degenerate: ignore zero-length matches.
1476 * fetching_unmatched: caller wants to fetch unmatched substrings.
1477 *
1478 * We don't currently assume that fetching_unmatched is exclusive of fetching
1479 * the matched text too; if it's set, the conversion buffer is large enough to
1480 * fetch any single matched or unmatched string, but not any larger
1481 * substring. (In practice, when splitting the matches are usually small
1482 * anyway, and it didn't seem worth complicating the code further.)
1483 */
1484static regexp_matches_ctx *
1485 setup_regexp_matches(text *orig_str, text *pattern, pg_re_flags *re_flags,
1486 int start_search,
1487 Oid collation,
1488 bool use_subpatterns,
1489 bool ignore_degenerate,
1490 bool fetching_unmatched)
1491{
1492 regexp_matches_ctx *matchctx = palloc0(sizeof(regexp_matches_ctx));
1493 int eml = pg_database_encoding_max_length();
1494 int orig_len;
1495 pg_wchar *wide_str;
1496 int wide_len;
1497 int cflags;
1498 regex_t *cpattern;
1499 regmatch_t *pmatch;
1500 int pmatch_len;
1501 int array_len;
1502 int array_idx;
1503 int prev_match_end;
1504 int prev_valid_match_end;
1505 int maxlen = 0; /* largest fetch length in characters */
1506
1507 /* save original string --- we'll extract result substrings from it */
1508 matchctx->orig_str = orig_str;
1509
1510 /* convert string to pg_wchar form for matching */
1511 orig_len = VARSIZE_ANY_EXHDR(orig_str);
1512 wide_str = (pg_wchar *) palloc(sizeof(pg_wchar) * (orig_len + 1));
1513 wide_len = pg_mb2wchar_with_len(VARDATA_ANY(orig_str), wide_str, orig_len);
1514
1515 /* set up the compiled pattern */
1516 cflags = re_flags->cflags;
1517 if (!use_subpatterns)
1518 cflags |= REG_NOSUB;
1519 cpattern = RE_compile_and_cache(pattern, cflags, collation);
1520
1521 /* do we want to remember subpatterns? */
1522 if (use_subpatterns && cpattern->re_nsub > 0)
1523 {
1524 matchctx->npatterns = cpattern->re_nsub;
1525 pmatch_len = cpattern->re_nsub + 1;
1526 }
1527 else
1528 {
1529 use_subpatterns = false;
1530 matchctx->npatterns = 1;
1531 pmatch_len = 1;
1532 }
1533
1534 /* temporary output space for RE package */
1535 pmatch = palloc(sizeof(regmatch_t) * pmatch_len);
1536
1537 /*
1538 * the real output space (grown dynamically if needed)
1539 *
1540 * use values 2^n-1, not 2^n, so that we hit the limit at 2^28-1 rather
1541 * than at 2^27
1542 */
1543 array_len = re_flags->glob ? 255 : 31;
1544 matchctx->match_locs = (int *) palloc(sizeof(int) * array_len);
1545 array_idx = 0;
1546
1547 /* search for the pattern, perhaps repeatedly */
1548 prev_match_end = 0;
1549 prev_valid_match_end = 0;
1550 while (RE_wchar_execute(cpattern, wide_str, wide_len, start_search,
1551 pmatch_len, pmatch))
1552 {
1553 /*
1554 * If requested, ignore degenerate matches, which are zero-length
1555 * matches occurring at the start or end of a string or just after a
1556 * previous match.
1557 */
1558 if (!ignore_degenerate ||
1559 (pmatch[0].rm_so < wide_len &&
1560 pmatch[0].rm_eo > prev_match_end))
1561 {
1562 /* enlarge output space if needed */
1563 while (array_idx + matchctx->npatterns * 2 + 1 > array_len)
1564 {
1565 array_len += array_len + 1; /* 2^n-1 => 2^(n+1)-1 */
1566 if (array_len > MaxAllocSize / sizeof(int))
1567 ereport(ERROR,
1568 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
1569 errmsg("too many regular expression matches")));
1570 matchctx->match_locs = (int *) repalloc(matchctx->match_locs,
1571 sizeof(int) * array_len);
1572 }
1573
1574 /* save this match's locations */
1575 if (use_subpatterns)
1576 {
1577 int i;
1578
1579 for (i = 1; i <= matchctx->npatterns; i++)
1580 {
1581 int so = pmatch[i].rm_so;
1582 int eo = pmatch[i].rm_eo;
1583
1584 matchctx->match_locs[array_idx++] = so;
1585 matchctx->match_locs[array_idx++] = eo;
1586 if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
1587 maxlen = (eo - so);
1588 }
1589 }
1590 else
1591 {
1592 int so = pmatch[0].rm_so;
1593 int eo = pmatch[0].rm_eo;
1594
1595 matchctx->match_locs[array_idx++] = so;
1596 matchctx->match_locs[array_idx++] = eo;
1597 if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
1598 maxlen = (eo - so);
1599 }
1600 matchctx->nmatches++;
1601
1602 /*
1603 * check length of unmatched portion between end of previous valid
1604 * (nondegenerate, or degenerate but not ignored) match and start
1605 * of current one
1606 */
1607 if (fetching_unmatched &&
1608 pmatch[0].rm_so >= 0 &&
1609 (pmatch[0].rm_so - prev_valid_match_end) > maxlen)
1610 maxlen = (pmatch[0].rm_so - prev_valid_match_end);
1611 prev_valid_match_end = pmatch[0].rm_eo;
1612 }
1613 prev_match_end = pmatch[0].rm_eo;
1614
1615 /* if not glob, stop after one match */
1616 if (!re_flags->glob)
1617 break;
1618
1619 /*
1620 * Advance search position. Normally we start the next search at the
1621 * end of the previous match; but if the match was of zero length, we
1622 * have to advance by one character, or we'd just find the same match
1623 * again.
1624 */
1625 start_search = prev_match_end;
1626 if (pmatch[0].rm_so == pmatch[0].rm_eo)
1627 start_search++;
1628 if (start_search > wide_len)
1629 break;
1630 }
1631
1632 /*
1633 * check length of unmatched portion between end of last match and end of
1634 * input string
1635 */
1636 if (fetching_unmatched &&
1637 (wide_len - prev_valid_match_end) > maxlen)
1638 maxlen = (wide_len - prev_valid_match_end);
1639
1640 /*
1641 * Keep a note of the end position of the string for the benefit of
1642 * splitting code.
1643 */
1644 matchctx->match_locs[array_idx] = wide_len;
1645
1646 if (eml > 1)
1647 {
1648 int64 maxsiz = eml * (int64) maxlen;
1649 int conv_bufsiz;
1650
1651 /*
1652 * Make the conversion buffer large enough for any substring of
1653 * interest.
1654 *
1655 * Worst case: assume we need the maximum size (maxlen*eml), but take
1656 * advantage of the fact that the original string length in bytes is
1657 * an upper bound on the byte length of any fetched substring (and we
1658 * know that len+1 is safe to allocate because the varlena header is
1659 * longer than 1 byte).
1660 */
1661 if (maxsiz > orig_len)
1662 conv_bufsiz = orig_len + 1;
1663 else
1664 conv_bufsiz = maxsiz + 1; /* safe since maxsiz < 2^30 */
1665
1666 matchctx->conv_buf = palloc(conv_bufsiz);
1667 matchctx->conv_bufsiz = conv_bufsiz;
1668 matchctx->wide_str = wide_str;
1669 }
1670 else
1671 {
1672 /* No need to keep the wide string if we're in a single-byte charset. */
1673 pfree(wide_str);
1674 matchctx->wide_str = NULL;
1675 matchctx->conv_buf = NULL;
1676 matchctx->conv_bufsiz = 0;
1677 }
1678
1679 /* Clean up temp storage */
1680 pfree(pmatch);
1681
1682 return matchctx;
1683}
1684
1685/*
1686 * build_regexp_match_result - build output array for current match
1687 */
1688static ArrayType *
1689 build_regexp_match_result(regexp_matches_ctx *matchctx)
1690{
1691 char *buf = matchctx->conv_buf;
1692 Datum *elems = matchctx->elems;
1693 bool *nulls = matchctx->nulls;
1694 int dims[1];
1695 int lbs[1];
1696 int loc;
1697 int i;
1698
1699 /* Extract matching substrings from the original string */
1700 loc = matchctx->next_match * matchctx->npatterns * 2;
1701 for (i = 0; i < matchctx->npatterns; i++)
1702 {
1703 int so = matchctx->match_locs[loc++];
1704 int eo = matchctx->match_locs[loc++];
1705
1706 if (so < 0 || eo < 0)
1707 {
1708 elems[i] = (Datum) 0;
1709 nulls[i] = true;
1710 }
1711 else if (buf)
1712 {
1713 int len = pg_wchar2mb_with_len(matchctx->wide_str + so,
1714 buf,
1715 eo - so);
1716
1717 Assert(len < matchctx->conv_bufsiz);
1718 elems[i] = PointerGetDatum(cstring_to_text_with_len(buf, len));
1719 nulls[i] = false;
1720 }
1721 else
1722 {
1723 elems[i] = DirectFunctionCall3(text_substr,
1724 PointerGetDatum(matchctx->orig_str),
1725 Int32GetDatum(so + 1),
1726 Int32GetDatum(eo - so));
1727 nulls[i] = false;
1728 }
1729 }
1730
1731 /* And form an array */
1732 dims[0] = matchctx->npatterns;
1733 lbs[0] = 1;
1734 /* XXX: this hardcodes assumptions about the text type */
1735 return construct_md_array(elems, nulls, 1, dims, lbs,
1736 TEXTOID, -1, false, TYPALIGN_INT);
1737}
1738
1739/*
1740 * regexp_split_to_table()
1741 * Split the string at matches of the pattern, returning the
1742 * split-out substrings as a table.
1743 */
1744Datum
1745 regexp_split_to_table(PG_FUNCTION_ARGS)
1746{
1747 FuncCallContext *funcctx;
1748 regexp_matches_ctx *splitctx;
1749
1750 if (SRF_IS_FIRSTCALL())
1751 {
1752 text *pattern = PG_GETARG_TEXT_PP(1);
1753 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
1754 pg_re_flags re_flags;
1755 MemoryContext oldcontext;
1756
1757 funcctx = SRF_FIRSTCALL_INIT();
1758 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1759
1760 /* Determine options */
1761 parse_re_flags(&re_flags, flags);
1762 /* User mustn't specify 'g' */
1763 if (re_flags.glob)
1764 ereport(ERROR,
1765 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1766 /* translator: %s is a SQL function name */
1767 errmsg("%s does not support the \"global\" option",
1768 "regexp_split_to_table()")));
1769 /* But we find all the matches anyway */
1770 re_flags.glob = true;
1771
1772 /* be sure to copy the input string into the multi-call ctx */
1773 splitctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
1774 &re_flags, 0,
1775 PG_GET_COLLATION(),
1776 false, true, true);
1777
1778 MemoryContextSwitchTo(oldcontext);
1779 funcctx->user_fctx = splitctx;
1780 }
1781
1782 funcctx = SRF_PERCALL_SETUP();
1783 splitctx = (regexp_matches_ctx *) funcctx->user_fctx;
1784
1785 if (splitctx->next_match <= splitctx->nmatches)
1786 {
1787 Datum result = build_regexp_split_result(splitctx);
1788
1789 splitctx->next_match++;
1790 SRF_RETURN_NEXT(funcctx, result);
1791 }
1792
1793 SRF_RETURN_DONE(funcctx);
1794}
1795
1796/* This is separate to keep the opr_sanity regression test from complaining */
1797Datum
1798 regexp_split_to_table_no_flags(PG_FUNCTION_ARGS)
1799{
1800 return regexp_split_to_table(fcinfo);
1801}
1802
1803/*
1804 * regexp_split_to_array()
1805 * Split the string at matches of the pattern, returning the
1806 * split-out substrings as an array.
1807 */
1808Datum
1809 regexp_split_to_array(PG_FUNCTION_ARGS)
1810{
1811 ArrayBuildState *astate = NULL;
1812 pg_re_flags re_flags;
1813 regexp_matches_ctx *splitctx;
1814
1815 /* Determine options */
1816 parse_re_flags(&re_flags, PG_GETARG_TEXT_PP_IF_EXISTS(2));
1817 /* User mustn't specify 'g' */
1818 if (re_flags.glob)
1819 ereport(ERROR,
1820 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1821 /* translator: %s is a SQL function name */
1822 errmsg("%s does not support the \"global\" option",
1823 "regexp_split_to_array()")));
1824 /* But we find all the matches anyway */
1825 re_flags.glob = true;
1826
1827 splitctx = setup_regexp_matches(PG_GETARG_TEXT_PP(0),
1828 PG_GETARG_TEXT_PP(1),
1829 &re_flags, 0,
1830 PG_GET_COLLATION(),
1831 false, true, true);
1832
1833 while (splitctx->next_match <= splitctx->nmatches)
1834 {
1835 astate = accumArrayResult(astate,
1836 build_regexp_split_result(splitctx),
1837 false,
1838 TEXTOID,
1839 CurrentMemoryContext);
1840 splitctx->next_match++;
1841 }
1842
1843 PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
1844}
1845
1846/* This is separate to keep the opr_sanity regression test from complaining */
1847Datum
1848 regexp_split_to_array_no_flags(PG_FUNCTION_ARGS)
1849{
1850 return regexp_split_to_array(fcinfo);
1851}
1852
1853/*
1854 * build_regexp_split_result - build output string for current match
1855 *
1856 * We return the string between the current match and the previous one,
1857 * or the string after the last match when next_match == nmatches.
1858 */
1859static Datum
1860 build_regexp_split_result(regexp_matches_ctx *splitctx)
1861{
1862 char *buf = splitctx->conv_buf;
1863 int startpos;
1864 int endpos;
1865
1866 if (splitctx->next_match > 0)
1867 startpos = splitctx->match_locs[splitctx->next_match * 2 - 1];
1868 else
1869 startpos = 0;
1870 if (startpos < 0)
1871 elog(ERROR, "invalid match ending position");
1872
1873 endpos = splitctx->match_locs[splitctx->next_match * 2];
1874 if (endpos < startpos)
1875 elog(ERROR, "invalid match starting position");
1876
1877 if (buf)
1878 {
1879 int len;
1880
1881 len = pg_wchar2mb_with_len(splitctx->wide_str + startpos,
1882 buf,
1883 endpos - startpos);
1884 Assert(len < splitctx->conv_bufsiz);
1885 return PointerGetDatum(cstring_to_text_with_len(buf, len));
1886 }
1887 else
1888 {
1889 return DirectFunctionCall3(text_substr,
1890 PointerGetDatum(splitctx->orig_str),
1891 Int32GetDatum(startpos + 1),
1892 Int32GetDatum(endpos - startpos));
1893 }
1894}
1895
1896/*
1897 * regexp_substr()
1898 * Return the substring that matches a regular expression pattern
1899 */
1900Datum
1901 regexp_substr(PG_FUNCTION_ARGS)
1902{
1903 text *str = PG_GETARG_TEXT_PP(0);
1904 text *pattern = PG_GETARG_TEXT_PP(1);
1905 int start = 1;
1906 int n = 1;
1907 text *flags = PG_GETARG_TEXT_PP_IF_EXISTS(4);
1908 int subexpr = 0;
1909 int so,
1910 eo,
1911 pos;
1912 pg_re_flags re_flags;
1913 regexp_matches_ctx *matchctx;
1914
1915 /* Collect optional parameters */
1916 if (PG_NARGS() > 2)
1917 {
1918 start = PG_GETARG_INT32(2);
1919 if (start <= 0)
1920 ereport(ERROR,
1921 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1922 errmsg("invalid value for parameter \"%s\": %d",
1923 "start", start)));
1924 }
1925 if (PG_NARGS() > 3)
1926 {
1927 n = PG_GETARG_INT32(3);
1928 if (n <= 0)
1929 ereport(ERROR,
1930 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1931 errmsg("invalid value for parameter \"%s\": %d",
1932 "n", n)));
1933 }
1934 if (PG_NARGS() > 5)
1935 {
1936 subexpr = PG_GETARG_INT32(5);
1937 if (subexpr < 0)
1938 ereport(ERROR,
1939 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1940 errmsg("invalid value for parameter \"%s\": %d",
1941 "subexpr", subexpr)));
1942 }
1943
1944 /* Determine options */
1945 parse_re_flags(&re_flags, flags);
1946 /* User mustn't specify 'g' */
1947 if (re_flags.glob)
1948 ereport(ERROR,
1949 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1950 /* translator: %s is a SQL function name */
1951 errmsg("%s does not support the \"global\" option",
1952 "regexp_substr()")));
1953 /* But we find all the matches anyway */
1954 re_flags.glob = true;
1955
1956 /* Do the matching */
1957 matchctx = setup_regexp_matches(str, pattern, &re_flags, start - 1,
1958 PG_GET_COLLATION(),
1959 (subexpr > 0), /* need submatches? */
1960 false, false);
1961
1962 /* When n exceeds matches return NULL (includes case of no matches) */
1963 if (n > matchctx->nmatches)
1964 PG_RETURN_NULL();
1965
1966 /* When subexpr exceeds number of subexpressions return NULL */
1967 if (subexpr > matchctx->npatterns)
1968 PG_RETURN_NULL();
1969
1970 /* Select the appropriate match position to return */
1971 pos = (n - 1) * matchctx->npatterns;
1972 if (subexpr > 0)
1973 pos += subexpr - 1;
1974 pos *= 2;
1975 so = matchctx->match_locs[pos];
1976 eo = matchctx->match_locs[pos + 1];
1977
1978 if (so < 0 || eo < 0)
1979 PG_RETURN_NULL(); /* unidentifiable location */
1980
1981 PG_RETURN_DATUM(DirectFunctionCall3(text_substr,
1982 PointerGetDatum(matchctx->orig_str),
1983 Int32GetDatum(so + 1),
1984 Int32GetDatum(eo - so)));
1985}
1986
1987/* This is separate to keep the opr_sanity regression test from complaining */
1988Datum
1989 regexp_substr_no_start(PG_FUNCTION_ARGS)
1990{
1991 return regexp_substr(fcinfo);
1992}
1993
1994/* This is separate to keep the opr_sanity regression test from complaining */
1995Datum
1996 regexp_substr_no_n(PG_FUNCTION_ARGS)
1997{
1998 return regexp_substr(fcinfo);
1999}
2000
2001/* This is separate to keep the opr_sanity regression test from complaining */
2002Datum
2003 regexp_substr_no_flags(PG_FUNCTION_ARGS)
2004{
2005 return regexp_substr(fcinfo);
2006}
2007
2008/* This is separate to keep the opr_sanity regression test from complaining */
2009Datum
2010 regexp_substr_no_subexpr(PG_FUNCTION_ARGS)
2011{
2012 return regexp_substr(fcinfo);
2013}
2014
2015/*
2016 * regexp_fixed_prefix - extract fixed prefix, if any, for a regexp
2017 *
2018 * The result is NULL if there is no fixed prefix, else a palloc'd string.
2019 * If it is an exact match, not just a prefix, *exact is returned as true.
2020 */
2021char *
2022 regexp_fixed_prefix(text *text_re, bool case_insensitive, Oid collation,
2023 bool *exact)
2024{
2025 char *result;
2026 regex_t *re;
2027 int cflags;
2028 int re_result;
2029 pg_wchar *str;
2030 size_t slen;
2031 size_t maxlen;
2032 char errMsg[100];
2033
2034 *exact = false; /* default result */
2035
2036 /* Compile RE */
2037 cflags = REG_ADVANCED;
2038 if (case_insensitive)
2039 cflags |= REG_ICASE;
2040
2041 re = RE_compile_and_cache(text_re, cflags | REG_NOSUB, collation);
2042
2043 /* Examine it to see if there's a fixed prefix */
2044 re_result = pg_regprefix(re, &str, &slen);
2045
2046 switch (re_result)
2047 {
2048 case REG_NOMATCH:
2049 return NULL;
2050
2051 case REG_PREFIX:
2052 /* continue with wchar conversion */
2053 break;
2054
2055 case REG_EXACT:
2056 *exact = true;
2057 /* continue with wchar conversion */
2058 break;
2059
2060 default:
2061 /* re failed??? */
2062 pg_regerror(re_result, re, errMsg, sizeof(errMsg));
2063 ereport(ERROR,
2064 (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
2065 errmsg("regular expression failed: %s", errMsg)));
2066 break;
2067 }
2068
2069 /* Convert pg_wchar result back to database encoding */
2070 maxlen = pg_database_encoding_max_length() * slen + 1;
2071 result = (char *) palloc(maxlen);
2072 slen = pg_wchar2mb_with_len(str, result, slen);
2073 Assert(slen < maxlen);
2074
2075 pfree(str);
2076
2077 return result;
2078}
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5351
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:3495
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5421
#define NameStr(name)
Definition: c.h:751
#define VARHDRSZ
Definition: c.h:697
int64_t int64
Definition: c.h:535
#define unlikely(x)
Definition: c.h:402
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:150
#define MaxAllocSize
Definition: fe_memutils.h:22
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_ARGISNULL(n)
Definition: fmgr.h:209
#define PG_NARGS()
Definition: fmgr.h:203
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_GETARG_NAME(n)
Definition: fmgr.h:278
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define PG_RETURN_DATUM(x)
Definition: fmgr.h:353
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:686
#define PG_GET_COLLATION()
Definition: fmgr.h:198
#define PG_GETARG_TEXT_P_COPY(n)
Definition: fmgr.h:315
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:304
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:308
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:310
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:306
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:328
Assert(PointerIsAligned(start, uint64))
return str start
const char * str
i
int i
Definition: isn.c:77
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
unsigned int pg_wchar
Definition: mbprint.c:31
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:1058
int pg_wchar2mb_with_len(const pg_wchar *from, char *to, int len)
Definition: mbutils.c:1009
int pg_database_encoding_max_length(void)
Definition: mbutils.c:1547
int pg_mb2wchar_with_len(const char *from, pg_wchar *to, int len)
Definition: mbutils.c:987
int pg_mblen(const char *mbstr)
Definition: mbutils.c:1024
void MemoryContextSetParent(MemoryContext context, MemoryContext new_parent)
Definition: mcxt.c:683
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1610
void pfree(void *pointer)
Definition: mcxt.c:1594
void * palloc0(Size size)
Definition: mcxt.c:1395
MemoryContext TopMemoryContext
Definition: mcxt.c:166
void * palloc(Size size)
Definition: mcxt.c:1365
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:469
void MemoryContextSetIdentifier(MemoryContext context, const char *id)
Definition: mcxt.c:658
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:170
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
static AmcheckOptions opts
Definition: pg_amcheck.c:112
const void size_t len
const void * data
static XLogRecPtr endpos
Definition: pg_receivewal.c:56
static XLogRecPtr startpos
Definition: pg_recvlogical.c:50
static char * buf
Definition: pg_test_fsync.c:72
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
uint64_t Datum
Definition: postgres.h:70
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:222
unsigned int Oid
Definition: postgres_ext.h:32
e
e
Definition: preproc-init.c:82
int pg_regcomp(regex_t *re, const chr *string, size_t len, int flags, Oid collation)
Definition: regcomp.c:372
size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
Definition: regerror.c:60
#define REG_ICASE
Definition: regex.h:184
#define REG_NOMATCH
Definition: regex.h:216
#define REG_EXACT
Definition: regex.h:240
#define REG_PREFIX
Definition: regex.h:239
#define REG_ADVANCED
Definition: regex.h:181
#define REG_EXPANDED
Definition: regex.h:186
#define REG_NLANCH
Definition: regex.h:188
#define REG_EXTENDED
Definition: regex.h:179
#define REG_NLSTOP
Definition: regex.h:187
#define regmatch_t
Definition: regex.h:246
#define REG_OKAY
Definition: regex.h:215
#define REG_NEWLINE
Definition: regex.h:189
#define REG_NOSUB
Definition: regex.h:185
#define regex_t
Definition: regex.h:245
#define REG_QUOTE
Definition: regex.h:182
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:185
struct regexp_matches_ctx regexp_matches_ctx
static MemoryContext RegexpCacheMemoryContext
Definition: regexp.c:99
regex_t * RE_compile_and_cache(text *text_re, int cflags, Oid collation)
Definition: regexp.c:141
Datum regexp_match_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1400
Datum textregexreplace(PG_FUNCTION_ARGS)
Definition: regexp.c:658
Datum texticregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:564
Datum regexp_substr_no_start(PG_FUNCTION_ARGS)
Definition: regexp.c:1989
struct pg_re_flags pg_re_flags
Datum regexp_split_to_array(PG_FUNCTION_ARGS)
Definition: regexp.c:1809
#define MAX_CACHED_RES
Definition: regexp.c:95
Datum texticregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:550
Datum regexp_substr_no_n(PG_FUNCTION_ARGS)
Definition: regexp.c:1996
Datum regexp_instr_no_subexpr(PG_FUNCTION_ARGS)
Definition: regexp.c:1316
Datum similar_to_escape_2(PG_FUNCTION_ARGS)
Definition: regexp.c:1075
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:358
char * regexp_fixed_prefix(text *text_re, bool case_insensitive, Oid collation, bool *exact)
Definition: regexp.c:2022
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:282
Datum regexp_substr(PG_FUNCTION_ARGS)
Definition: regexp.c:1901
Datum nameicregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:536
Datum textregexsubstr(PG_FUNCTION_ARGS)
Definition: regexp.c:583
static Datum build_regexp_split_result(regexp_matches_ctx *splitctx)
Definition: regexp.c:1860
static int num_res
Definition: regexp.c:112
Datum regexp_split_to_array_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1848
Datum textregexreplace_extended_no_n(PG_FUNCTION_ARGS)
Definition: regexp.c:744
static regexp_matches_ctx * setup_regexp_matches(text *orig_str, text *pattern, pg_re_flags *re_flags, int start_search, Oid collation, bool use_subpatterns, bool ignore_degenerate, bool fetching_unmatched)
Definition: regexp.c:1485
Datum nameregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:473
Datum regexp_instr(PG_FUNCTION_ARGS)
Definition: regexp.c:1195
static ArrayType * build_regexp_match_result(regexp_matches_ctx *matchctx)
Definition: regexp.c:1689
Datum similar_to_escape_1(PG_FUNCTION_ARGS)
Definition: regexp.c:1091
Datum regexp_substr_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:2003
Datum regexp_matches(PG_FUNCTION_ARGS)
Definition: regexp.c:1410
#define PG_GETARG_TEXT_PP_IF_EXISTS(_n)
Definition: regexp.c:40
Datum nameicregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:522
Datum regexp_matches_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1459
Datum regexp_split_to_table_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1798
Datum regexp_match(PG_FUNCTION_ARGS)
Definition: regexp.c:1364
Datum textregexreplace_extended(PG_FUNCTION_ARGS)
Definition: regexp.c:699
Datum nameregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:459
Datum regexp_instr_no_n(PG_FUNCTION_ARGS)
Definition: regexp.c:1295
Datum regexp_count_no_start(PG_FUNCTION_ARGS)
Definition: regexp.c:1178
struct cached_re_str cached_re_str
static cached_re_str re_array[MAX_CACHED_RES]
Definition: regexp.c:113
static bool RE_execute(regex_t *re, char *dat, int dat_len, int nmatch, regmatch_t *pmatch)
Definition: regexp.c:324
static void parse_re_flags(pg_re_flags *flags, text *opts)
Definition: regexp.c:385
Datum regexp_split_to_table(PG_FUNCTION_ARGS)
Definition: regexp.c:1745
Datum textregexreplace_noopt(PG_FUNCTION_ARGS)
Definition: regexp.c:642
Datum regexp_like_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1354
Datum regexp_instr_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1309
Datum textregexeq(PG_FUNCTION_ARGS)
Definition: regexp.c:487
Datum textregexne(PG_FUNCTION_ARGS)
Definition: regexp.c:501
Datum regexp_count_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:1185
Datum similar_escape(PG_FUNCTION_ARGS)
Definition: regexp.c:1109
Datum regexp_instr_no_start(PG_FUNCTION_ARGS)
Definition: regexp.c:1288
Datum regexp_instr_no_endoption(PG_FUNCTION_ARGS)
Definition: regexp.c:1302
Datum textregexreplace_extended_no_flags(PG_FUNCTION_ARGS)
Definition: regexp.c:751
Datum regexp_like(PG_FUNCTION_ARGS)
Definition: regexp.c:1326
Datum regexp_substr_no_subexpr(PG_FUNCTION_ARGS)
Definition: regexp.c:2010
static text * similar_escape_internal(text *pat_text, text *esc_text)
Definition: regexp.c:767
Datum regexp_count(PG_FUNCTION_ARGS)
Definition: regexp.c:1135
int pg_regprefix(regex_t *re, chr **string, size_t *slength)
Definition: regprefix.c:46
Definition: array.h:93
void * user_fctx
Definition: funcapi.h:82
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
Definition: regexp.c:103
char * cre_pat
Definition: regexp.c:105
int cre_pat_len
Definition: regexp.c:106
regex_t cre_re
Definition: regexp.c:109
Oid cre_collation
Definition: regexp.c:108
int cre_flags
Definition: regexp.c:107
MemoryContext cre_context
Definition: regexp.c:104
Definition: c.h:746
Definition: regexp.c:46
bool glob
Definition: regexp.c:48
int cflags
Definition: regexp.c:47
Definition: regexp.c:53
Datum * elems
Definition: regexp.c:62
text * orig_str
Definition: regexp.c:54
char * conv_buf
Definition: regexp.c:65
int * match_locs
Definition: regexp.c:59
int next_match
Definition: regexp.c:60
int npatterns
Definition: regexp.c:56
int nmatches
Definition: regexp.c:55
pg_wchar * wide_str
Definition: regexp.c:64
int conv_bufsiz
Definition: regexp.c:66
bool * nulls
Definition: regexp.c:63
Definition: c.h:692
static Size VARSIZE_ANY_EXHDR(const void *PTR)
Definition: varatt.h:472
static char * VARDATA(const void *PTR)
Definition: varatt.h:305
static char * VARDATA_ANY(const void *PTR)
Definition: varatt.h:486
static void SET_VARSIZE(void *PTR, Size len)
Definition: varatt.h:432
Datum text_substr(PG_FUNCTION_ARGS)
Definition: varlena.c:547
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:193
text * replace_text_regexp(text *src_text, text *pattern_text, text *replace_text, int cflags, Oid collation, int search_start, int n)
Definition: varlena.c:3302

AltStyle によって変換されたページ (->オリジナル) /