I have applied your patch, with slight adjustments in spacing and
documentation.
Patch applied. Thanks.
---------------------------------------------------------------------------
Atsushi Ogawa wrote:
>
> I made the patch that implements regexp_replace again.
> The specification of this function is as follows.
>
> regexp_replace(source text, pattern text, replacement text, [flags text])
> returns text
>
> Replace string that matches to regular expression in source text to
> replacement text.
>
> - pattern is regular expression pattern.
> - replacement is replace string that can use '\1'-'\9', and '\&'.
> '\1'-'\9': back reference to the n'th subexpression.
> '\&' : entire matched string.
> - flags can use the following values:
> g: global (replace all)
> i: ignore case
> When the flags is not specified, case sensitive, replace the first
> instance only.
>
> regards,
>
> --- Atsushi Ogawa
[ Attachment, skipping... ]
>
> ---------------------------(end of broadcast)---------------------------
> TIP 4: Don't 'kill -9' the postmaster
--
Bruce Momjian | http://candle.pha.pa.us
pgman@candle.pha.pa.us | (610) 359-1001
+ If your life is a hard drive, | 13 Roberts Road
+ Christ can be your backup. | Newtown Square, Pennsylvania 19073
Index: doc/src/sgml/func.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/func.sgml,v
retrieving revision 1.263
diff -c -c -r1.263 func.sgml
*** doc/src/sgml/func.sgml 6 Jul 2005 19:02:52 -0000 1.263
--- doc/src/sgml/func.sgml 10 Jul 2005 04:52:43 -0000
***************
*** 1257,1262 ****
--- 1257,1282 ----
</row>
<row>
+ <entry><literal><function>regexp_replace</function>(<parameter>source</parameter> <type>text</type>,
+ <parameter>pattern</parameter> <type>text</type>,
+ <parameter>replacement</parameter> <type>text</type>
+ <optional>, <parameter>flags</parameter> <type>text</type></optional>)</literal></entry>
+ <entry><type>text</type></entry>
+ <entry>Replace string that matches the regular expression
+ <parameter>pattern</parameter> in <parameter>source</parameter> to
+ <parameter>replacement</parameter>.
+ <parameter>replacement</parameter> can use <literal>\1</>-<literal>\9</> and <literal>\&</>.
+ <literal>\1</>-<literal>\9</> is a back reference to the n'th subexpression, and
+ <literal>\&</> is the entire matched string.
+ <parameter>flags</parameter> can use <literal>g</>(global) and <literal>i</>(ignore case).
+ When flags is not specified, case sensitive matching is used, and it replaces
+ only the instance.
+ </entry>
+ <entry><literal>regexp_replace('1112223333', '(\\d{3})(\\d{3})(\\d{4})', '(\\1) \\2-\\3')</literal></entry>
+ <entry><literal>(111) 222-3333</literal></entry>
+ </row>
+
+ <row>
<entry><literal><function>repeat</function>(<parameter>string</parameter> <type>text</type>,
<parameter>number</parameter><type>integer</type>)</literal></entry>
<entry><type>text</type></entry>
<entry>Repeat <parameter>string</parameter> the specified
Index: src/backend/regex/regexec.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/regex/regexec.c,v
retrieving revision 1.24
diff -c -c -r1.24 regexec.c
*** src/backend/regex/regexec.c 29 Nov 2003 19:51:55 -0000 1.24
--- src/backend/regex/regexec.c 10 Jul 2005 04:52:44 -0000
***************
*** 110,115 ****
--- 110,116 ----
regmatch_t *pmatch;
rm_detail_t *details;
chr *start; /* start of string */
+ chr *search_start; /* search start of string */
chr *stop; /* just past end of string */
int err; /* error code if any (0 none) */
regoff_t *mem; /* memory vector for backtracking */
***************
*** 168,173 ****
--- 169,175 ----
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[],
***************
*** 219,224 ****
--- 221,227 ----
v->pmatch = pmatch;
v->details = details;
v->start = (chr *) string;
+ v->search_start = (chr *) string + search_start;
v->stop = (chr *) string + len;
v->err = 0;
if (backref)
***************
*** 288,294 ****
NOERR();
MDEBUG(("\nsearch at %ld\n", LOFF(v->start)));
cold = NULL;
! close = shortest(v, s, v->start, v->start, v->stop, &cold, (int *) NULL);
freedfa(s);
NOERR();
if (v->g->cflags & REG_EXPECT)
--- 291,298 ----
NOERR();
MDEBUG(("\nsearch at %ld\n", LOFF(v->start)));
cold = NULL;
! close = shortest(v, s, v->search_start, v->search_start, v->stop,
! &cold, (int *) NULL);
freedfa(s);
NOERR();
if (v->g->cflags & REG_EXPECT)
***************
*** 415,421 ****
assert(d != NULL && s != NULL);
cold = NULL;
! close = v->start;
do
{
MDEBUG(("\ncsearch at %ld\n", LOFF(close)));
--- 419,425 ----
assert(d != NULL && s != NULL);
cold = NULL;
! close = v->search_start;
do
{
MDEBUG(("\ncsearch at %ld\n", LOFF(close)));
Index: src/backend/utils/adt/regexp.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/adt/regexp.c,v
retrieving revision 1.56
diff -c -c -r1.56 regexp.c
*** src/backend/utils/adt/regexp.c 31 Dec 2004 22:01:22 -0000 1.56
--- src/backend/utils/adt/regexp.c 10 Jul 2005 04:52:45 -0000
***************
*** 81,118 ****
/*
! * RE_compile_and_execute - compile and execute a RE, caching if possible
*
! * Returns TRUE on match, FALSE on no match
*
! * text_re --- the pattern, expressed as an *untoasted* TEXT object
! * dat --- the data to match against (need not be null-terminated)
! * dat_len --- the length of the data string
! * cflags --- compile options for the pattern
! * nmatch, pmatch --- optional return area for match details
*
! * Both pattern and data are given in the database encoding. We internally
! * convert to array of pg_wchar which is what Spencer's regex package wants.
*/
! static bool
! RE_compile_and_execute(text *text_re, unsigned char *dat, int dat_len,
! int cflags, int nmatch, regmatch_t *pmatch)
{
int text_re_len = VARSIZE(text_re);
- pg_wchar *data;
- size_t data_len;
pg_wchar *pattern;
size_t pattern_len;
int i;
int regcomp_result;
- int regexec_result;
cached_re_str re_temp;
char errMsg[100];
- /* Convert data string to wide characters */
- data = (pg_wchar *) palloc((dat_len + 1) * sizeof(pg_wchar));
- data_len = pg_mb2wchar_with_len(dat, data, dat_len);
-
/*
* Look for a match among previously compiled REs. Since the data
* structure is self-organizing with most-used entries at the front,
--- 81,107 ----
/*
! * RE_compile_and_cache - compile a RE, caching if possible
*
! * Returns regex_t
*
! * text_re --- the pattern, expressed as an *untoasted* TEXT object
! * cflags --- compile options for the pattern
*
! * Pattern is given in the database encoding. We internally convert to
! * array of pg_wchar which is what Spencer's regex package wants.
*/
! static regex_t
! RE_compile_and_cache(text *text_re, int cflags)
{
int text_re_len = VARSIZE(text_re);
pg_wchar *pattern;
size_t pattern_len;
int i;
int regcomp_result;
cached_re_str re_temp;
char errMsg[100];
/*
* Look for a match among previously compiled REs. Since the data
* structure is self-organizing with most-used entries at the front,
***************
*** 134,161 ****
re_array[0] = re_temp;
}
! /* Perform RE match and return result */
! regexec_result = pg_regexec(&re_array[0].cre_re,
! data,
! data_len,
! NULL, /* no details */
! nmatch,
! pmatch,
! 0);
!
! pfree(data);
!
! if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
! {
! /* re failed??? */
! pg_regerror(regexec_result, &re_array[0].cre_re,
! errMsg, sizeof(errMsg));
! ereport(ERROR,
! (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
! errmsg("regular expression failed: %s", errMsg)));
! }
!
! return (regexec_result == REG_OKAY);
}
}
--- 123,129 ----
re_array[0] = re_temp;
}
! return re_array[0].cre_re;
}
}
***************
*** 220,229 ****
--- 188,232 ----
re_array[0] = re_temp;
num_res++;
+ return re_array[0].cre_re;
+ }
+
+ /*
+ * RE_compile_and_execute - compile and execute a RE
+ *
+ * Returns TRUE on match, FALSE on no match
+ *
+ * text_re --- the pattern, expressed as an *untoasted* TEXT object
+ * dat --- the data to match against (need not be null-terminated)
+ * dat_len --- the length of the data string
+ * cflags --- compile options for the pattern
+ * nmatch, pmatch --- optional return area for match details
+ *
+ * Both pattern and data are given in the database encoding. We internally
+ * convert to array of pg_wchar which is what Spencer's regex package wants.
+ */
+ static bool
+ RE_compile_and_execute(text *text_re, unsigned char *dat, int dat_len,
+ int cflags, int nmatch, regmatch_t *pmatch)
+ {
+ pg_wchar *data;
+ size_t data_len;
+ int regexec_result;
+ regex_t re;
+ char errMsg[100];
+
+ /* Convert data string to wide characters */
+ data = (pg_wchar *) palloc((dat_len + 1) * sizeof(pg_wchar));
+ data_len = pg_mb2wchar_with_len(dat, data, dat_len);
+
+ /* Compile RE */
+ re = RE_compile_and_cache(text_re, cflags);
+
/* Perform RE match and return result */
regexec_result = pg_regexec(&re_array[0].cre_re,
data,
data_len,
+ 0,
NULL, /* no details */
nmatch,
pmatch,
***************
*** 428,442 ****
eo = pmatch[0].rm_eo;
}
! return (DirectFunctionCall3(text_substr,
PointerGetDatum(s),
Int32GetDatum(so + 1),
! Int32GetDatum(eo - so)));
}
PG_RETURN_NULL();
}
/* similar_escape()
* Convert a SQL99 regexp pattern to POSIX style, so it can be used by
* our regexp engine.
--- 431,519 ----
eo = pmatch[0].rm_eo;
}
! return DirectFunctionCall3(text_substr,
PointerGetDatum(s),
Int32GetDatum(so + 1),
! Int32GetDatum(eo - so));
}
PG_RETURN_NULL();
}
+ /*
+ * textregexreplace_noopt()
+ * Return a replace string matched by a regular expression.
+ * This function is a version that doesn't specify the option of
+ * textregexreplace. This is case sensitive, replace the first
+ * instance only.
+ */
+ Datum
+ textregexreplace_noopt(PG_FUNCTION_ARGS)
+ {
+ text *s = PG_GETARG_TEXT_P(0);
+ text *p = PG_GETARG_TEXT_P(1);
+ text *r = PG_GETARG_TEXT_P(2);
+ regex_t re;
+
+ re = RE_compile_and_cache(p, regex_flavor);
+
+ return DirectFunctionCall4(replace_text_regexp,
+ PointerGetDatum(s),
+ PointerGetDatum(&re),
+ PointerGetDatum(r),
+ BoolGetDatum(false));
+ }
+
+ /*
+ * textregexreplace()
+ * Return a replace string matched by a regular expression.
+ */
+ Datum
+ textregexreplace(PG_FUNCTION_ARGS)
+ {
+ text *s = PG_GETARG_TEXT_P(0);
+ text *p = PG_GETARG_TEXT_P(1);
+ text *r = PG_GETARG_TEXT_P(2);
+ text *opt = PG_GETARG_TEXT_P(3);
+ char *opt_p = VARDATA(opt);
+ int opt_len = (VARSIZE(opt) - VARHDRSZ);
+ int i;
+ bool global = false;
+ bool ignorecase = false;
+ regex_t re;
+
+ /* parse options */
+ for (i = 0; i < opt_len; i++)
+ {
+ switch (opt_p[i])
+ {
+ case 'i':
+ ignorecase = true;
+ break;
+ case 'g':
+ global = true;
+ break;
+ default:
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("invalid option of regexp_replace: %c",
+ opt_p[i])));
+ break;
+ }
+ }
+
+ if (ignorecase)
+ re = RE_compile_and_cache(p, regex_flavor | REG_ICASE);
+ else
+ re = RE_compile_and_cache(p, regex_flavor);
+
+ return DirectFunctionCall4(replace_text_regexp,
+ PointerGetDatum(s),
+ PointerGetDatum(&re),
+ PointerGetDatum(r),
+ BoolGetDatum(global));
+ }
+
/* similar_escape()
* Convert a SQL99 regexp pattern to POSIX style, so it can be used by
* our regexp engine.
Index: src/backend/utils/adt/varlena.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v
retrieving revision 1.126
diff -c -c -r1.126 varlena.c
*** src/backend/utils/adt/varlena.c 7 Jul 2005 04:36:08 -0000 1.126
--- src/backend/utils/adt/varlena.c 10 Jul 2005 04:52:46 -0000
***************
*** 28,33 ****
--- 28,34 ----
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/pg_locale.h"
+ #include "regex/regex.h"
typedef struct varlena unknown;
***************
*** 1994,1999 ****
--- 1995,2219 ----
}
/*
+ * check_replace_text_has_escape_char
+ * check whether replace_text has escape char.
+ */
+ static bool
+ check_replace_text_has_escape_char(const text *replace_text)
+ {
+ const char *p = VARDATA(replace_text);
+ const char *p_end = p + (VARSIZE(replace_text) - VARHDRSZ);
+
+ if (pg_database_encoding_max_length() == 1)
+ {
+ for (; p < p_end; p++)
+ if (*p == '\\') return true;
+ }
+ else
+ {
+ for (; p < p_end; p += pg_mblen(p))
+ if (*p == '\\') return true;
+ }
+
+ return false;
+ }
+
+ /*
+ * appendStringInfoRegexpSubstr
+ * append string by using back references of regexp.
+ */
+ static void
+ appendStringInfoRegexpSubstr(StringInfo str, text *replace_text,
+ regmatch_t *pmatch, text *src_text)
+ {
+ const char *p = VARDATA(replace_text);
+ const char *p_end = p + (VARSIZE(replace_text) - VARHDRSZ);
+
+ int eml = pg_database_encoding_max_length();
+
+ int substr_start = 1;
+ int ch_cnt;
+
+ int so;
+ int eo;
+
+ while (1)
+ {
+ /* Find escape char. */
+ ch_cnt = 0;
+ if (eml == 1)
+ {
+ for (; p < p_end && *p != '\\'; p++)
+ ch_cnt++;
+ }
+ else
+ {
+ for (; p < p_end && *p != '\\'; p += pg_mblen(p))
+ ch_cnt++;
+ }
+
+ /*
+ * Copy the text when there is a text in the left of escape char
+ * or escape char is not found.
+ */
+ if (ch_cnt)
+ {
+ text *append_text = text_substring(PointerGetDatum(replace_text),
+ substr_start, ch_cnt, false);
+ appendStringInfoString(str, PG_TEXT_GET_STR(append_text));
+ pfree(append_text);
+ }
+ substr_start += ch_cnt + 1;
+
+ if (p >= p_end) /* When escape char is not found. */
+ break;
+
+ /* See the next character of escape char. */
+ p++;
+ so = eo = -1;
+
+ if (*p >= '1' && *p <= '9')
+ {
+ /* Use the back reference of regexp. */
+ int idx = *p - '0';
+ so = pmatch[idx].rm_so;
+ eo = pmatch[idx].rm_eo;
+ p++;
+ substr_start++;
+ }
+ else if (*p == '&')
+ {
+ /* Use the entire matched string. */
+ so = pmatch[0].rm_so;
+ eo = pmatch[0].rm_eo;
+ p++;
+ substr_start++;
+ }
+
+ if (so != -1 && eo != -1)
+ {
+ /* Copy the text that is back reference of regexp. */
+ text *append_text = text_substring(PointerGetDatum(src_text),
+ so + 1, (eo - so), false);
+ appendStringInfoString(str, PG_TEXT_GET_STR(append_text));
+ pfree(append_text);
+ }
+ }
+ }
+
+ #define REGEXP_REPLACE_BACKREF_CNT 10
+
+ /*
+ * replace_text_regexp
+ * replace text that matches to regexp in src_text to replace_text.
+ */
+ Datum
+ replace_text_regexp(PG_FUNCTION_ARGS)
+ {
+ text *ret_text;
+ text *src_text = PG_GETARG_TEXT_P(0);
+ int src_text_len = VARSIZE(src_text) - VARHDRSZ;
+ regex_t *re = (regex_t *)PG_GETARG_POINTER(1);
+ text *replace_text = PG_GETARG_TEXT_P(2);
+ bool global = PG_GETARG_BOOL(3);
+ StringInfo str = makeStringInfo();
+ int regexec_result;
+ regmatch_t pmatch[REGEXP_REPLACE_BACKREF_CNT];
+ pg_wchar *data;
+ size_t data_len;
+ int search_start;
+ int data_pos;
+ bool have_escape;
+
+ /* Convert data string to wide characters. */
+ data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar));
+ data_len = pg_mb2wchar_with_len(VARDATA(src_text), data, src_text_len);
+
+ /* Check whether replace_text has escape char. */
+ have_escape = check_replace_text_has_escape_char(replace_text);
+
+ for (search_start = data_pos = 0; search_start <= data_len;)
+ {
+ regexec_result = pg_regexec(re,
+ data,
+ data_len,
+ search_start,
+ NULL, /* no details */
+ REGEXP_REPLACE_BACKREF_CNT,
+ pmatch,
+ 0);
+
+ if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
+ {
+ char errMsg[100];
+
+ /* re failed??? */
+ pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
+ errmsg("regular expression failed: %s", errMsg)));
+ }
+
+ if (regexec_result == REG_NOMATCH)
+ break;
+
+ /*
+ * Copy the text when there is a text in the left of matched position.
+ */
+ if (pmatch[0].rm_so - data_pos > 0)
+ {
+ text *left_text = text_substring(PointerGetDatum(src_text),
+ data_pos + 1,
+ pmatch[0].rm_so - data_pos, false);
+ appendStringInfoString(str, PG_TEXT_GET_STR(left_text));
+ pfree(left_text);
+ }
+
+ /*
+ * Copy the replace_text. Process back references when the
+ * replace_text has escape characters.
+ */
+ if (have_escape)
+ appendStringInfoRegexpSubstr(str, replace_text, pmatch, src_text);
+ else
+ appendStringInfoString(str, PG_TEXT_GET_STR(replace_text));
+
+ search_start = data_pos = pmatch[0].rm_eo;
+
+ /*
+ * When global option is off, replace the first instance only.
+ */
+ if (!global)
+ break;
+
+ /*
+ * Search from next character when the matching text is zero width.
+ */
+ if (pmatch[0].rm_so == pmatch[0].rm_eo)
+ search_start++;
+ }
+
+ /*
+ * Copy the text when there is a text at the right of last matched
+ * or regexp is not matched.
+ */
+ if (data_pos < data_len)
+ {
+ text *right_text = text_substring(PointerGetDatum(src_text),
+ data_pos + 1, -1, true);
+ appendStringInfoString(str, PG_TEXT_GET_STR(right_text));
+ pfree(right_text);
+ }
+
+ ret_text = PG_STR_GET_TEXT(str->data);
+ pfree(str->data);
+ pfree(str);
+ pfree(data);
+
+ PG_RETURN_TEXT_P(ret_text);
+ }
+
+ /*
* split_text
* parse input string
* return ord item (1 based)
Index: src/include/catalog/catversion.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/catalog/catversion.h,v
retrieving revision 1.286
diff -c -c -r1.286 catversion.h
*** src/include/catalog/catversion.h 8 Jul 2005 04:12:26 -0000 1.286
--- src/include/catalog/catversion.h 10 Jul 2005 04:52:46 -0000
***************
*** 53,58 ****
*/
/* yyyymmddN */
! #define CATALOG_VERSION_NO 200507081
#endif
--- 53,58 ----
*/
/* yyyymmddN */
! #define CATALOG_VERSION_NO 200507101
#endif
Index: src/include/catalog/pg_proc.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/catalog/pg_proc.h,v
retrieving revision 1.374
diff -c -c -r1.374 pg_proc.h
*** src/include/catalog/pg_proc.h 6 Jul 2005 19:02:53 -0000 1.374
--- src/include/catalog/pg_proc.h 10 Jul 2005 04:52:51 -0000
***************
*** 2207,2212 ****
--- 2207,2216 ----
DESCR("return portion of string");
DATA(insert OID = 2087 ( replace PGNSP PGUID 12 f f t f i 3 25 "25 25 25" _null_ _null_ _null_ replace_text
-_null_ ));
DESCR("replace all occurrences of old_substr with new_substr in string");
+ DATA(insert OID = 2284 ( regexp_replace PGNSP PGUID 12 f f t f i 3 25 "25 25 25" _null_ _null_ _null_
textregexreplace_noopt- _null_ ));
+ DESCR("replace text using regexp");
+ DATA(insert OID = 2285 ( regexp_replace PGNSP PGUID 12 f f t f i 4 25 "25 25 25 25" _null_ _null_ _null_
textregexreplace- _null_ ));
+ DESCR("replace text using regexp");
DATA(insert OID = 2088 ( split_part PGNSP PGUID 12 f f t f i 3 25 "25 25 23" _null_ _null_ _null_ split_text -
_null_));
DESCR("split string by field_sep and return field_num");
DATA(insert OID = 2089 ( to_hex PGNSP PGUID 12 f f t f i 1 25 "23" _null_ _null_ _null_ to_hex32 - _null_ ));
Index: src/include/regex/regex.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/regex/regex.h,v
retrieving revision 1.26
diff -c -c -r1.26 regex.h
*** src/include/regex/regex.h 29 Nov 2003 22:41:10 -0000 1.26
--- src/include/regex/regex.h 10 Jul 2005 04:52:51 -0000
***************
*** 163,169 ****
* the prototypes for exported functions
*/
extern int pg_regcomp(regex_t *, const pg_wchar *, size_t, int);
! extern int pg_regexec(regex_t *, const pg_wchar *, size_t, rm_detail_t *, size_t, regmatch_t[], int);
extern void pg_regfree(regex_t *);
extern size_t pg_regerror(int, const regex_t *, char *, size_t);
--- 163,169 ----
* the prototypes for exported functions
*/
extern int pg_regcomp(regex_t *, const pg_wchar *, size_t, int);
! extern int pg_regexec(regex_t *, const pg_wchar *, size_t, size_t, rm_detail_t *, size_t, regmatch_t[], int);
extern void pg_regfree(regex_t *);
extern size_t pg_regerror(int, const regex_t *, char *, size_t);
Index: src/include/utils/builtins.h
===================================================================
RCS file: /cvsroot/pgsql/src/include/utils/builtins.h,v
retrieving revision 1.259
diff -c -c -r1.259 builtins.h
*** src/include/utils/builtins.h 6 Jul 2005 19:02:54 -0000 1.259
--- src/include/utils/builtins.h 10 Jul 2005 04:52:52 -0000
***************
*** 429,434 ****
--- 429,436 ----
extern Datum texticregexeq(PG_FUNCTION_ARGS);
extern Datum texticregexne(PG_FUNCTION_ARGS);
extern Datum textregexsubstr(PG_FUNCTION_ARGS);
+ extern Datum textregexreplace_noopt(PG_FUNCTION_ARGS);
+ extern Datum textregexreplace(PG_FUNCTION_ARGS);
extern Datum similar_escape(PG_FUNCTION_ARGS);
/* regproc.c */
***************
*** 566,571 ****
--- 568,574 ----
extern bool SplitIdentifierString(char *rawstring, char separator,
List **namelist);
extern Datum replace_text(PG_FUNCTION_ARGS);
+ extern Datum replace_text_regexp(PG_FUNCTION_ARGS);
extern Datum split_text(PG_FUNCTION_ARGS);
extern Datum text_to_array(PG_FUNCTION_ARGS);
extern Datum array_to_text(PG_FUNCTION_ARGS);
Index: src/test/regress/expected/strings.out
===================================================================
RCS file: /cvsroot/pgsql/src/test/regress/expected/strings.out,v
retrieving revision 1.25
diff -c -c -r1.25 strings.out
*** src/test/regress/expected/strings.out 20 May 2005 01:29:56 -0000 1.25
--- src/test/regress/expected/strings.out 10 Jul 2005 04:52:52 -0000
***************
*** 192,197 ****
--- 192,225 ----
cde
(1 row)
+ -- PostgreSQL extension to allow using back reference in replace string;
+ SELECT regexp_replace('1112223333', '(\\d{3})(\\d{3})(\\d{4})', '(\\1) \\2-\\3');
+ regexp_replace
+ ----------------
+ (111) 222-3333
+ (1 row)
+
+ SELECT regexp_replace('AAA BBB CCC ', '\\s+', ' ', 'g');
+ regexp_replace
+ ----------------
+ AAA BBB CCC
+ (1 row)
+
+ SELECT regexp_replace('AAA', '^|$', 'Z', 'g');
+ regexp_replace
+ ----------------
+ ZAAAZ
+ (1 row)
+
+ SELECT regexp_replace('AAA aaa', 'A+', 'Z', 'gi');
+ regexp_replace
+ ----------------
+ Z Z
+ (1 row)
+
+ -- invalid option of REGEXP_REPLACE
+ SELECT regexp_replace('AAA aaa', 'A+', 'Z', 'z');
+ ERROR: invalid option of regexp_replace: z
-- E021-11 position expression
SELECT POSITION('4' IN '1234567890') = '4' AS "4";
4
Index: src/test/regress/sql/strings.sql
===================================================================
RCS file: /cvsroot/pgsql/src/test/regress/sql/strings.sql,v
retrieving revision 1.16
diff -c -c -r1.16 strings.sql
*** src/test/regress/sql/strings.sql 20 May 2005 01:29:56 -0000 1.16
--- src/test/regress/sql/strings.sql 10 Jul 2005 04:52:53 -0000
***************
*** 80,85 ****
--- 80,92 ----
-- With a parenthesized subexpression, return only what matches the subexpr
SELECT SUBSTRING('abcdefg' FROM 'b(.*)f') AS "cde";
+ -- PostgreSQL extension to allow using back reference in replace string;
+ SELECT regexp_replace('1112223333', '(\\d{3})(\\d{3})(\\d{4})', '(\\1) \\2-\\3');
+ SELECT regexp_replace('AAA BBB CCC ', '\\s+', ' ', 'g');
+ SELECT regexp_replace('AAA', '^|$', 'Z', 'g');
+ SELECT regexp_replace('AAA aaa', 'A+', 'Z', 'gi');
+ -- invalid option of REGEXP_REPLACE
+ SELECT regexp_replace('AAA aaa', 'A+', 'Z', 'z');
-- E021-11 position expression
SELECT POSITION('4' IN '1234567890') = '4' AS "4";
