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