regexp.c File Reference

#include "postgres.h"
#include "catalog/pg_type.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "regex/regex.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/varlena.h"

Include dependency graph for regexp.c:

Go to the source code of this file.

Data Structures
struct	pg_re_flags
struct	regexp_matches_ctx
struct	cached_re_str

Macros
#define	PG_GETARG_TEXT_PP_IF_EXISTS(_n)    (PG_NARGS() > (_n) ? PG_GETARG_TEXT_PP(_n) : NULL)
#define	MAX_CACHED_RES   32

Typedefs
typedef struct pg_re_flags	pg_re_flags
typedef struct regexp_matches_ctx	regexp_matches_ctx
typedef struct cached_re_str	cached_re_str

Functions
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)
static ArrayType *	build_regexp_match_result (regexp_matches_ctx *matchctx)
static Datum	build_regexp_split_result (regexp_matches_ctx *splitctx)
regex_t *	RE_compile_and_cache (text *text_re, int cflags, Oid collation)
static bool	RE_wchar_execute (regex_t *re, pg_wchar *data, int data_len, int start_search, int nmatch, regmatch_t *pmatch)
static bool	RE_execute (regex_t *re, char *dat, int dat_len, int nmatch, regmatch_t *pmatch)
bool	RE_compile_and_execute (text *text_re, char *dat, int dat_len, int cflags, Oid collation, int nmatch, regmatch_t *pmatch)
static void	parse_re_flags (pg_re_flags *flags, text *opts)
Datum	nameregexeq (PG_FUNCTION_ARGS)
Datum	nameregexne (PG_FUNCTION_ARGS)
Datum	textregexeq (PG_FUNCTION_ARGS)
Datum	textregexne (PG_FUNCTION_ARGS)
Datum	nameicregexeq (PG_FUNCTION_ARGS)
Datum	nameicregexne (PG_FUNCTION_ARGS)
Datum	texticregexeq (PG_FUNCTION_ARGS)
Datum	texticregexne (PG_FUNCTION_ARGS)
Datum	textregexsubstr (PG_FUNCTION_ARGS)
Datum	textregexreplace_noopt (PG_FUNCTION_ARGS)
Datum	textregexreplace (PG_FUNCTION_ARGS)
Datum	textregexreplace_extended (PG_FUNCTION_ARGS)
Datum	textregexreplace_extended_no_n (PG_FUNCTION_ARGS)
Datum	textregexreplace_extended_no_flags (PG_FUNCTION_ARGS)
static text *	similar_escape_internal (text *pat_text, text *esc_text)
Datum	similar_to_escape_2 (PG_FUNCTION_ARGS)
Datum	similar_to_escape_1 (PG_FUNCTION_ARGS)
Datum	similar_escape (PG_FUNCTION_ARGS)
Datum	regexp_count (PG_FUNCTION_ARGS)
Datum	regexp_count_no_start (PG_FUNCTION_ARGS)
Datum	regexp_count_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_instr (PG_FUNCTION_ARGS)
Datum	regexp_instr_no_start (PG_FUNCTION_ARGS)
Datum	regexp_instr_no_n (PG_FUNCTION_ARGS)
Datum	regexp_instr_no_endoption (PG_FUNCTION_ARGS)
Datum	regexp_instr_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_instr_no_subexpr (PG_FUNCTION_ARGS)
Datum	regexp_like (PG_FUNCTION_ARGS)
Datum	regexp_like_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_match (PG_FUNCTION_ARGS)
Datum	regexp_match_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_matches (PG_FUNCTION_ARGS)
Datum	regexp_matches_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_split_to_table (PG_FUNCTION_ARGS)
Datum	regexp_split_to_table_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_split_to_array (PG_FUNCTION_ARGS)
Datum	regexp_split_to_array_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_substr (PG_FUNCTION_ARGS)
Datum	regexp_substr_no_start (PG_FUNCTION_ARGS)
Datum	regexp_substr_no_n (PG_FUNCTION_ARGS)
Datum	regexp_substr_no_flags (PG_FUNCTION_ARGS)
Datum	regexp_substr_no_subexpr (PG_FUNCTION_ARGS)
char *	regexp_fixed_prefix (text *text_re, bool case_insensitive, Oid collation, bool *exact)

Variables
static MemoryContext	RegexpCacheMemoryContext
static int	num_res = 0
static cached_re_str	re_array [MAX_CACHED_RES]

Macro Definition Documentation

MAX_CACHED_RES

#define MAX_CACHED_RES   32

Definition at line 96 of file regexp.c.

PG_GETARG_TEXT_PP_IF_EXISTS

#define PG_GETARG_TEXT_PP_IF_EXISTS

(

_n

)

(PG_NARGS() > (_n) ? PG_GETARG_TEXT_PP(_n) : NULL)

Definition at line 41 of file regexp.c.

Typedef Documentation

cached_re_str

typedef struct cached_re_str cached_re_str

pg_re_flags

typedef struct pg_re_flags pg_re_flags

regexp_matches_ctx

typedef struct regexp_matches_ctx regexp_matches_ctx

Function Documentation

build_regexp_match_result()

static ArrayType * build_regexp_match_result ( regexp_matches_ctx *  matchctx )

static

Definition at line 1621 of file regexp.c.

{
    char       *buf = matchctx->conv_buf;
    Datum      *elems = matchctx->elems;
    bool       *nulls = matchctx->nulls;
    int         dims[1];
    int         lbs[1];
    int         loc;
    int         i;
 
    /* Extract matching substrings from the original string */
    loc = matchctx->next_match * matchctx->npatterns * 2;
    for (i = 0; i < matchctx->npatterns; i++)
    {
        int         so = matchctx->match_locs[loc++];
        int         eo = matchctx->match_locs[loc++];
 
        if (so < 0 || eo < 0)
        {
            elems[i] = (Datum) 0;
            nulls[i] = true;
        }
        else if (buf)
        {
            int         len = pg_wchar2mb_with_len(matchctx->wide_str + so,
                                                   buf,
                                                   eo - so);
 
            Assert(len < matchctx->conv_bufsiz);
            elems[i] = PointerGetDatum(cstring_to_text_with_len(buf, len));
            nulls[i] = false;
        }
        else
        {
            elems[i] = DirectFunctionCall3(text_substr,
                                           PointerGetDatum(matchctx->orig_str),
                                           Int32GetDatum(so + 1),
                                           Int32GetDatum(eo - so));
            nulls[i] = false;
        }
    }
 
    /* And form an array */
    dims[0] = matchctx->npatterns;
    lbs[0] = 1;
    /* XXX: this hardcodes assumptions about the text type */
    return construct_md_array(elems, nulls, 1, dims, lbs,
                              TEXTOID, -1, false, TYPALIGN_INT);
}

References Assert(), buf, construct_md_array(), regexp_matches_ctx::conv_buf, cstring_to_text_with_len(), DirectFunctionCall3, regexp_matches_ctx::elems, i, Int32GetDatum(), len, regexp_matches_ctx::match_locs, regexp_matches_ctx::next_match, regexp_matches_ctx::npatterns, regexp_matches_ctx::nulls, regexp_matches_ctx::orig_str, pg_wchar2mb_with_len(), PointerGetDatum(), text_substr(), and regexp_matches_ctx::wide_str.

Referenced by regexp_match(), and regexp_matches().

build_regexp_split_result()

static Datum build_regexp_split_result ( regexp_matches_ctx *  splitctx )

static

Definition at line 1792 of file regexp.c.

{
    char       *buf = splitctx->conv_buf;
    int         startpos;
    int         endpos;
 
    if (splitctx->next_match > 0)
        startpos = splitctx->match_locs[splitctx->next_match * 2 - 1];
    else
        startpos = 0;
    if (startpos < 0)
        elog(ERROR, "invalid match ending position");
 
    endpos = splitctx->match_locs[splitctx->next_match * 2];
    if (endpos < startpos)
        elog(ERROR, "invalid match starting position");
 
    if (buf)
    {
        int         len;
 
        len = pg_wchar2mb_with_len(splitctx->wide_str + startpos,
                                   buf,
                                   endpos - startpos);
        Assert(len < splitctx->conv_bufsiz);
        return PointerGetDatum(cstring_to_text_with_len(buf, len));
    }
    else
    {
        return DirectFunctionCall3(text_substr,
                                   PointerGetDatum(splitctx->orig_str),
                                   Int32GetDatum(startpos + 1),
                                   Int32GetDatum(endpos - startpos));
    }
}

References Assert(), buf, regexp_matches_ctx::conv_buf, cstring_to_text_with_len(), DirectFunctionCall3, elog(), endpos, ERROR, Int32GetDatum(), len, regexp_matches_ctx::match_locs, regexp_matches_ctx::next_match, regexp_matches_ctx::orig_str, pg_wchar2mb_with_len(), PointerGetDatum(), startpos, text_substr(), and regexp_matches_ctx::wide_str.

Referenced by regexp_split_to_array(), and regexp_split_to_table().

nameicregexeq()

Datum nameicregexeq

(

PG_FUNCTION_ARGS

)

Definition at line 523 of file regexp.c.

{
    Name        n = PG_GETARG_NAME(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(RE_compile_and_execute(p,
                                          NameStr(*n),
                                          strlen(NameStr(*n)),
                                          REG_ADVANCED | REG_ICASE,
                                          PG_GET_COLLATION(),
                                          0, NULL));
}

References NameStr, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), REG_ADVANCED, and REG_ICASE.

nameicregexne()

Datum nameicregexne

(

PG_FUNCTION_ARGS

)

Definition at line 537 of file regexp.c.

{
    Name        n = PG_GETARG_NAME(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(!RE_compile_and_execute(p,
                                           NameStr(*n),
                                           strlen(NameStr(*n)),
                                           REG_ADVANCED | REG_ICASE,
                                           PG_GET_COLLATION(),
                                           0, NULL));
}

References NameStr, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), REG_ADVANCED, and REG_ICASE.

nameregexeq()

Datum nameregexeq

(

PG_FUNCTION_ARGS

)

Definition at line 460 of file regexp.c.

{
    Name        n = PG_GETARG_NAME(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(RE_compile_and_execute(p,
                                          NameStr(*n),
                                          strlen(NameStr(*n)),
                                          REG_ADVANCED,
                                          PG_GET_COLLATION(),
                                          0, NULL));
}

References NameStr, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), and REG_ADVANCED.

nameregexne()

Datum nameregexne

(

PG_FUNCTION_ARGS

)

Definition at line 474 of file regexp.c.

{
    Name        n = PG_GETARG_NAME(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(!RE_compile_and_execute(p,
                                           NameStr(*n),
                                           strlen(NameStr(*n)),
                                           REG_ADVANCED,
                                           PG_GET_COLLATION(),
                                           0, NULL));
}

References NameStr, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), and REG_ADVANCED.

parse_re_flags()

static void parse_re_flags ( pg_re_flags *  flags, text *  opts  )

static

Definition at line 386 of file regexp.c.

{
    /* regex flavor is always folded into the compile flags */
    flags->cflags = REG_ADVANCED;
    flags->glob = false;
 
    if (opts)
    {
        char       *opt_p = VARDATA_ANY(opts);
        int         opt_len = VARSIZE_ANY_EXHDR(opts);
        int         i;
 
        for (i = 0; i < opt_len; i++)
        {
            switch (opt_p[i])
            {
                case 'g':
                    flags->glob = true;
                    break;
                case 'b':       /* BREs (but why???) */
                    flags->cflags &= ~(REG_ADVANCED | REG_EXTENDED | REG_QUOTE);
                    break;
                case 'c':       /* case sensitive */
                    flags->cflags &= ~REG_ICASE;
                    break;
                case 'e':       /* plain EREs */
                    flags->cflags |= REG_EXTENDED;
                    flags->cflags &= ~(REG_ADVANCED | REG_QUOTE);
                    break;
                case 'i':       /* case insensitive */
                    flags->cflags |= REG_ICASE;
                    break;
                case 'm':       /* Perloid synonym for n */
                case 'n':       /* \n affects ^ $ . [^ */
                    flags->cflags |= REG_NEWLINE;
                    break;
                case 'p':       /* ~Perl, \n affects . [^ */
                    flags->cflags |= REG_NLSTOP;
                    flags->cflags &= ~REG_NLANCH;
                    break;
                case 'q':       /* literal string */
                    flags->cflags |= REG_QUOTE;
                    flags->cflags &= ~(REG_ADVANCED | REG_EXTENDED);
                    break;
                case 's':       /* single line, \n ordinary */
                    flags->cflags &= ~REG_NEWLINE;
                    break;
                case 't':       /* tight syntax */
                    flags->cflags &= ~REG_EXPANDED;
                    break;
                case 'w':       /* weird, \n affects ^ $ only */
                    flags->cflags &= ~REG_NLSTOP;
                    flags->cflags |= REG_NLANCH;
                    break;
                case 'x':       /* expanded syntax */
                    flags->cflags |= REG_EXPANDED;
                    break;
                default:
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("invalid regular expression option: \"%.*s\"",
                                    pg_mblen(opt_p + i), opt_p + i)));
                    break;
            }
        }
    }
}

References pg_re_flags::cflags, ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, i, opts, pg_mblen(), REG_ADVANCED, REG_EXPANDED, REG_EXTENDED, REG_ICASE, REG_NEWLINE, REG_NLANCH, REG_NLSTOP, REG_QUOTE, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by regexp_count(), regexp_instr(), regexp_like(), regexp_match(), regexp_matches(), regexp_split_to_array(), regexp_split_to_table(), regexp_substr(), textregexreplace(), and textregexreplace_extended().

RE_compile_and_cache()

regex_t* RE_compile_and_cache	(	text *	text_re,
		int	cflags,
		Oid	collation
	)

Definition at line 142 of file regexp.c.

{
    int         text_re_len = VARSIZE_ANY_EXHDR(text_re);
    char       *text_re_val = VARDATA_ANY(text_re);
    pg_wchar   *pattern;
    int         pattern_len;
    int         i;
    int         regcomp_result;
    cached_re_str re_temp;
    char        errMsg[100];
    MemoryContext oldcontext;
 
    /*
     * Look for a match among previously compiled REs.  Since the data
     * structure is self-organizing with most-used entries at the front, our
     * search strategy can just be to scan from the front.
     */
    for (i = 0; i < num_res; i++)
    {
        if (re_array[i].cre_pat_len == text_re_len &&
            re_array[i].cre_flags == cflags &&
            re_array[i].cre_collation == collation &&
            memcmp(re_array[i].cre_pat, text_re_val, text_re_len) == 0)
        {
            /*
             * Found a match; move it to front if not there already.
             */
            if (i > 0)
            {
                re_temp = re_array[i];
                memmove(&re_array[1], &re_array[0], i * sizeof(cached_re_str));
                re_array[0] = re_temp;
            }
 
            return &re_array[0].cre_re;
        }
    }
 
    /* Set up the cache memory on first go through. */
    if (unlikely(RegexpCacheMemoryContext == NULL))
        RegexpCacheMemoryContext =
            AllocSetContextCreate(TopMemoryContext,
                                  "RegexpCacheMemoryContext",
                                  ALLOCSET_SMALL_SIZES);
 
    /*
     * Couldn't find it, so try to compile the new RE.  To avoid leaking
     * resources on failure, we build into the re_temp local.
     */
 
    /* Convert pattern string to wide characters */
    pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar));
    pattern_len = pg_mb2wchar_with_len(text_re_val,
                                       pattern,
                                       text_re_len);
 
    /*
     * Make a memory context for this compiled regexp.  This is initially a
     * child of the current memory context, so it will be cleaned up
     * automatically if compilation is interrupted and throws an ERROR. We'll
     * re-parent it under the longer lived cache context if we make it to the
     * bottom of this function.
     */
    re_temp.cre_context = AllocSetContextCreate(CurrentMemoryContext,
                                                "RegexpMemoryContext",
                                                ALLOCSET_SMALL_SIZES);
    oldcontext = MemoryContextSwitchTo(re_temp.cre_context);
 
    regcomp_result = pg_regcomp(&re_temp.cre_re,
                                pattern,
                                pattern_len,
                                cflags,
                                collation);
 
    pfree(pattern);
 
    if (regcomp_result != REG_OKAY)
    {
        /* re didn't compile (no need for pg_regfree, if so) */
        pg_regerror(regcomp_result, &re_temp.cre_re, errMsg, sizeof(errMsg));
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                 errmsg("invalid regular expression: %s", errMsg)));
    }
 
    /* Copy the pattern into the per-regexp memory context. */
    re_temp.cre_pat = palloc(text_re_len + 1);
    memcpy(re_temp.cre_pat, text_re_val, text_re_len);
 
    /*
     * NUL-terminate it only for the benefit of the identifier used for the
     * memory context, visible in the pg_backend_memory_contexts view.
     */
    re_temp.cre_pat[text_re_len] = 0;
    MemoryContextSetIdentifier(re_temp.cre_context, re_temp.cre_pat);
 
    re_temp.cre_pat_len = text_re_len;
    re_temp.cre_flags = cflags;
    re_temp.cre_collation = collation;
 
    /*
     * Okay, we have a valid new item in re_temp; insert it into the storage
     * array.  Discard last entry if needed.
     */
    if (num_res >= MAX_CACHED_RES)
    {
        --num_res;
        Assert(num_res < MAX_CACHED_RES);
        /* Delete the memory context holding the regexp and pattern. */
        MemoryContextDelete(re_array[num_res].cre_context);
    }
 
    /* Re-parent the memory context to our long-lived cache context. */
    MemoryContextSetParent(re_temp.cre_context, RegexpCacheMemoryContext);
 
    if (num_res > 0)
        memmove(&re_array[1], &re_array[0], num_res * sizeof(cached_re_str));
 
    re_array[0] = re_temp;
    num_res++;
 
    MemoryContextSwitchTo(oldcontext);
 
    return &re_array[0].cre_re;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert(), cached_re_str::cre_collation, cached_re_str::cre_context, cached_re_str::cre_flags, cached_re_str::cre_pat, cached_re_str::cre_pat_len, cached_re_str::cre_re, CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, i, MAX_CACHED_RES, MemoryContextDelete(), MemoryContextSetIdentifier(), MemoryContextSetParent(), MemoryContextSwitchTo(), num_res, palloc(), pfree(), pg_mb2wchar_with_len(), pg_regcomp(), pg_regerror(), re_array, REG_OKAY, RegexpCacheMemoryContext, TopMemoryContext, unlikely, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by RE_compile_and_execute(), regexp_fixed_prefix(), replace_text_regexp(), setup_regexp_matches(), and textregexsubstr().

RE_compile_and_execute()

bool RE_compile_and_execute	(	text *	text_re,
		char *	dat,
		int	dat_len,
		int	cflags,
		Oid	collation,
		int	nmatch,
		regmatch_t *	pmatch
	)

Definition at line 359 of file regexp.c.

{
    regex_t    *re;
 
    /* Use REG_NOSUB if caller does not want sub-match details */
    if (nmatch < 2)
        cflags |= REG_NOSUB;
 
    /* Compile RE */
    re = RE_compile_and_cache(text_re, cflags, collation);
 
    return RE_execute(re, dat, dat_len, nmatch, pmatch);
}

References RE_compile_and_cache(), RE_execute(), and REG_NOSUB.

Referenced by executeLikeRegex(), nameicregexeq(), nameicregexne(), nameregexeq(), nameregexne(), regexp_like(), texticregexeq(), texticregexne(), textregexeq(), and textregexne().

RE_execute()

static bool RE_execute ( regex_t *  re, char *  dat, int  dat_len, int  nmatch, regmatch_t *  pmatch  )

static

Definition at line 325 of file regexp.c.

{
    pg_wchar   *data;
    int         data_len;
    bool        match;
 
    /* 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);
 
    /* Perform RE match and return result */
    match = RE_wchar_execute(re, data, data_len, 0, nmatch, pmatch);
 
    pfree(data);
    return match;
}

References data, palloc(), pfree(), pg_mb2wchar_with_len(), and RE_wchar_execute().

Referenced by RE_compile_and_execute(), and textregexsubstr().

RE_wchar_execute()

static bool RE_wchar_execute ( regex_t *  re, pg_wchar *  data, int  data_len, int  start_search, int  nmatch, regmatch_t *  pmatch  )

static

Definition at line 283 of file regexp.c.

{
    int         regexec_result;
    char        errMsg[100];
 
    /* Perform RE match and return result */
    regexec_result = pg_regexec(re,
                                data,
                                data_len,
                                start_search,
                                NULL,   /* no details */
                                nmatch,
                                pmatch,
                                0);
 
    if (regexec_result != REG_OKAY && regexec_result != REG_NOMATCH)
    {
        /* re failed??? */
        pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                 errmsg("regular expression failed: %s", errMsg)));
    }
 
    return (regexec_result == REG_OKAY);
}

References data, ereport, errcode(), errmsg(), ERROR, pg_regerror(), pg_regexec(), REG_NOMATCH, and REG_OKAY.

Referenced by RE_execute(), and setup_regexp_matches().

regexp_count()

Datum regexp_count

(

PG_FUNCTION_ARGS

)

Definition at line 1067 of file regexp.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    text       *pattern = PG_GETARG_TEXT_PP(1);
    int         start = 1;
    text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(3);
    pg_re_flags re_flags;
    regexp_matches_ctx *matchctx;
 
    /* Collect optional parameters */
    if (PG_NARGS() > 2)
    {
        start = PG_GETARG_INT32(2);
        if (start <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "start", start)));
    }
 
    /* Determine options */
    parse_re_flags(&re_flags, flags);
    /* User mustn't specify 'g' */
    if (re_flags.glob)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        /* translator: %s is a SQL function name */
                 errmsg("%s does not support the \"global\" option",
                        "regexp_count()")));
    /* But we find all the matches anyway */
    re_flags.glob = true;
 
    /* Do the matching */
    matchctx = setup_regexp_matches(str, pattern, &re_flags, start - 1,
                                    PG_GET_COLLATION(),
                                    false,  /* can ignore subexprs */
                                    false, false);
 
    PG_RETURN_INT32(matchctx->nmatches);
}

References ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, regexp_matches_ctx::nmatches, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_NARGS, PG_RETURN_INT32, setup_regexp_matches(), and generate_unaccent_rules::str.

Referenced by regexp_count_no_flags(), and regexp_count_no_start().

regexp_count_no_flags()

Datum regexp_count_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1117 of file regexp.c.

{
    return regexp_count(fcinfo);
}

References regexp_count().

regexp_count_no_start()

Datum regexp_count_no_start

(

PG_FUNCTION_ARGS

)

Definition at line 1110 of file regexp.c.

{
    return regexp_count(fcinfo);
}

References regexp_count().

regexp_fixed_prefix()

char* regexp_fixed_prefix	(	text *	text_re,
		bool	case_insensitive,
		Oid	collation,
		bool *	exact
	)

Definition at line 1954 of file regexp.c.

{
    char       *result;
    regex_t    *re;
    int         cflags;
    int         re_result;
    pg_wchar   *str;
    size_t      slen;
    size_t      maxlen;
    char        errMsg[100];
 
    *exact = false;             /* default result */
 
    /* Compile RE */
    cflags = REG_ADVANCED;
    if (case_insensitive)
        cflags |= REG_ICASE;
 
    re = RE_compile_and_cache(text_re, cflags | REG_NOSUB, collation);
 
    /* Examine it to see if there's a fixed prefix */
    re_result = pg_regprefix(re, &str, &slen);
 
    switch (re_result)
    {
        case REG_NOMATCH:
            return NULL;
 
        case REG_PREFIX:
            /* continue with wchar conversion */
            break;
 
        case REG_EXACT:
            *exact = true;
            /* continue with wchar conversion */
            break;
 
        default:
            /* re failed??? */
            pg_regerror(re_result, re, errMsg, sizeof(errMsg));
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                     errmsg("regular expression failed: %s", errMsg)));
            break;
    }
 
    /* Convert pg_wchar result back to database encoding */
    maxlen = pg_database_encoding_max_length() * slen + 1;
    result = (char *) palloc(maxlen);
    slen = pg_wchar2mb_with_len(str, result, slen);
    Assert(slen < maxlen);
 
    pfree(str);
 
    return result;
}

References Assert(), ereport, errcode(), errmsg(), ERROR, palloc(), pfree(), pg_database_encoding_max_length(), pg_regerror(), pg_regprefix(), pg_wchar2mb_with_len(), RE_compile_and_cache(), REG_ADVANCED, REG_EXACT, REG_ICASE, REG_NOMATCH, REG_NOSUB, REG_PREFIX, and generate_unaccent_rules::str.

Referenced by regex_fixed_prefix().

regexp_instr()

Datum regexp_instr

(

PG_FUNCTION_ARGS

)

Definition at line 1127 of file regexp.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    text       *pattern = PG_GETARG_TEXT_PP(1);
    int         start = 1;
    int         n = 1;
    int         endoption = 0;
    text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(5);
    int         subexpr = 0;
    int         pos;
    pg_re_flags re_flags;
    regexp_matches_ctx *matchctx;
 
    /* Collect optional parameters */
    if (PG_NARGS() > 2)
    {
        start = PG_GETARG_INT32(2);
        if (start <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "start", start)));
    }
    if (PG_NARGS() > 3)
    {
        n = PG_GETARG_INT32(3);
        if (n <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "n", n)));
    }
    if (PG_NARGS() > 4)
    {
        endoption = PG_GETARG_INT32(4);
        if (endoption != 0 && endoption != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "endoption", endoption)));
    }
    if (PG_NARGS() > 6)
    {
        subexpr = PG_GETARG_INT32(6);
        if (subexpr < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "subexpr", subexpr)));
    }
 
    /* Determine options */
    parse_re_flags(&re_flags, flags);
    /* User mustn't specify 'g' */
    if (re_flags.glob)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        /* translator: %s is a SQL function name */
                 errmsg("%s does not support the \"global\" option",
                        "regexp_instr()")));
    /* But we find all the matches anyway */
    re_flags.glob = true;
 
    /* Do the matching */
    matchctx = setup_regexp_matches(str, pattern, &re_flags, start - 1,
                                    PG_GET_COLLATION(),
                                    (subexpr > 0),  /* need submatches? */
                                    false, false);
 
    /* When n exceeds matches return 0 (includes case of no matches) */
    if (n > matchctx->nmatches)
        PG_RETURN_INT32(0);
 
    /* When subexpr exceeds number of subexpressions return 0 */
    if (subexpr > matchctx->npatterns)
        PG_RETURN_INT32(0);
 
    /* Select the appropriate match position to return */
    pos = (n - 1) * matchctx->npatterns;
    if (subexpr > 0)
        pos += subexpr - 1;
    pos *= 2;
    if (endoption == 1)
        pos += 1;
 
    if (matchctx->match_locs[pos] >= 0)
        PG_RETURN_INT32(matchctx->match_locs[pos] + 1);
    else
        PG_RETURN_INT32(0);     /* position not identifiable */
}

References ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, if(), regexp_matches_ctx::match_locs, regexp_matches_ctx::nmatches, regexp_matches_ctx::npatterns, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_NARGS, PG_RETURN_INT32, setup_regexp_matches(), and generate_unaccent_rules::str.

Referenced by regexp_instr_no_endoption(), regexp_instr_no_flags(), regexp_instr_no_n(), regexp_instr_no_start(), and regexp_instr_no_subexpr().

regexp_instr_no_endoption()

Datum regexp_instr_no_endoption

(

PG_FUNCTION_ARGS

)

Definition at line 1234 of file regexp.c.

{
    return regexp_instr(fcinfo);
}

References regexp_instr().

regexp_instr_no_flags()

Datum regexp_instr_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1241 of file regexp.c.

{
    return regexp_instr(fcinfo);
}

References regexp_instr().

regexp_instr_no_n()

Datum regexp_instr_no_n

(

PG_FUNCTION_ARGS

)

Definition at line 1227 of file regexp.c.

{
    return regexp_instr(fcinfo);
}

References regexp_instr().

regexp_instr_no_start()

Datum regexp_instr_no_start

(

PG_FUNCTION_ARGS

)

Definition at line 1220 of file regexp.c.

{
    return regexp_instr(fcinfo);
}

References regexp_instr().

regexp_instr_no_subexpr()

Datum regexp_instr_no_subexpr

(

PG_FUNCTION_ARGS

)

Definition at line 1248 of file regexp.c.

{
    return regexp_instr(fcinfo);
}

References regexp_instr().

regexp_like()

Datum regexp_like

(

PG_FUNCTION_ARGS

)

Definition at line 1258 of file regexp.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    text       *pattern = PG_GETARG_TEXT_PP(1);
    text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
    pg_re_flags re_flags;
 
    /* Determine options */
    parse_re_flags(&re_flags, flags);
    /* User mustn't specify 'g' */
    if (re_flags.glob)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        /* translator: %s is a SQL function name */
                 errmsg("%s does not support the \"global\" option",
                        "regexp_like()")));
 
    /* Otherwise it's like textregexeq/texticregexeq */
    PG_RETURN_BOOL(RE_compile_and_execute(pattern,
                                          VARDATA_ANY(str),
                                          VARSIZE_ANY_EXHDR(str),
                                          re_flags.cflags,
                                          PG_GET_COLLATION(),
                                          0, NULL));
}

References pg_re_flags::cflags, ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_RETURN_BOOL, RE_compile_and_execute(), generate_unaccent_rules::str, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by regexp_like_no_flags().

regexp_like_no_flags()

Datum regexp_like_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1286 of file regexp.c.

{
    return regexp_like(fcinfo);
}

References regexp_like().

regexp_match()

Datum regexp_match

(

PG_FUNCTION_ARGS

)

Definition at line 1296 of file regexp.c.

{
    text       *orig_str = PG_GETARG_TEXT_PP(0);
    text       *pattern = PG_GETARG_TEXT_PP(1);
    text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
    pg_re_flags re_flags;
    regexp_matches_ctx *matchctx;
 
    /* Determine options */
    parse_re_flags(&re_flags, flags);
    /* User mustn't specify 'g' */
    if (re_flags.glob)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        /* translator: %s is a SQL function name */
                 errmsg("%s does not support the \"global\" option",
                        "regexp_match()"),
                 errhint("Use the regexp_matches function instead.")));
 
    matchctx = setup_regexp_matches(orig_str, pattern, &re_flags, 0,
                                    PG_GET_COLLATION(), true, false, false);
 
    if (matchctx->nmatches == 0)
        PG_RETURN_NULL();
 
    Assert(matchctx->nmatches == 1);
 
    /* Create workspace that build_regexp_match_result needs */
    matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
    matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
 
    PG_RETURN_DATUM(PointerGetDatum(build_regexp_match_result(matchctx)));
}

References Assert(), build_regexp_match_result(), regexp_matches_ctx::elems, ereport, errcode(), errhint(), errmsg(), ERROR, pg_re_flags::glob, regexp_matches_ctx::nmatches, regexp_matches_ctx::npatterns, regexp_matches_ctx::nulls, palloc(), parse_re_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_RETURN_DATUM, PG_RETURN_NULL, PointerGetDatum(), and setup_regexp_matches().

Referenced by regexp_match_no_flags().

regexp_match_no_flags()

Datum regexp_match_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1332 of file regexp.c.

{
    return regexp_match(fcinfo);
}

References regexp_match().

regexp_matches()

Datum regexp_matches

(

PG_FUNCTION_ARGS

)

Definition at line 1342 of file regexp.c.

{
    FuncCallContext *funcctx;
    regexp_matches_ctx *matchctx;
 
    if (SRF_IS_FIRSTCALL())
    {
        text       *pattern = PG_GETARG_TEXT_PP(1);
        text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
        pg_re_flags re_flags;
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* Determine options */
        parse_re_flags(&re_flags, flags);
 
        /* be sure to copy the input string into the multi-call ctx */
        matchctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
                                        &re_flags, 0,
                                        PG_GET_COLLATION(),
                                        true, false, false);
 
        /* Pre-create workspace that build_regexp_match_result needs */
        matchctx->elems = (Datum *) palloc(sizeof(Datum) * matchctx->npatterns);
        matchctx->nulls = (bool *) palloc(sizeof(bool) * matchctx->npatterns);
 
        MemoryContextSwitchTo(oldcontext);
        funcctx->user_fctx = (void *) matchctx;
    }
 
    funcctx = SRF_PERCALL_SETUP();
    matchctx = (regexp_matches_ctx *) funcctx->user_fctx;
 
    if (matchctx->next_match < matchctx->nmatches)
    {
        ArrayType  *result_ary;
 
        result_ary = build_regexp_match_result(matchctx);
        matchctx->next_match++;
        SRF_RETURN_NEXT(funcctx, PointerGetDatum(result_ary));
    }
 
    SRF_RETURN_DONE(funcctx);
}

References build_regexp_match_result(), regexp_matches_ctx::elems, if(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, regexp_matches_ctx::next_match, regexp_matches_ctx::nmatches, regexp_matches_ctx::npatterns, regexp_matches_ctx::nulls, palloc(), parse_re_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_P_COPY, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PointerGetDatum(), setup_regexp_matches(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

Referenced by regexp_matches_no_flags().

regexp_matches_no_flags()

Datum regexp_matches_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1391 of file regexp.c.

{
    return regexp_matches(fcinfo);
}

References regexp_matches().

regexp_split_to_array()

Datum regexp_split_to_array

(

PG_FUNCTION_ARGS

)

Definition at line 1741 of file regexp.c.

{
    ArrayBuildState *astate = NULL;
    pg_re_flags re_flags;
    regexp_matches_ctx *splitctx;
 
    /* Determine options */
    parse_re_flags(&re_flags, PG_GETARG_TEXT_PP_IF_EXISTS(2));
    /* User mustn't specify 'g' */
    if (re_flags.glob)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        /* translator: %s is a SQL function name */
                 errmsg("%s does not support the \"global\" option",
                        "regexp_split_to_array()")));
    /* But we find all the matches anyway */
    re_flags.glob = true;
 
    splitctx = setup_regexp_matches(PG_GETARG_TEXT_PP(0),
                                    PG_GETARG_TEXT_PP(1),
                                    &re_flags, 0,
                                    PG_GET_COLLATION(),
                                    false, true, true);
 
    while (splitctx->next_match <= splitctx->nmatches)
    {
        astate = accumArrayResult(astate,
                                  build_regexp_split_result(splitctx),
                                  false,
                                  TEXTOID,
                                  CurrentMemoryContext);
        splitctx->next_match++;
    }
 
    PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext));
}

References accumArrayResult(), build_regexp_split_result(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, makeArrayResult(), regexp_matches_ctx::next_match, regexp_matches_ctx::nmatches, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_RETURN_DATUM, and setup_regexp_matches().

Referenced by regexp_split_to_array_no_flags().

regexp_split_to_array_no_flags()

Datum regexp_split_to_array_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1780 of file regexp.c.

{
    return regexp_split_to_array(fcinfo);
}

References regexp_split_to_array().

regexp_split_to_table()

Datum regexp_split_to_table

(

PG_FUNCTION_ARGS

)

Definition at line 1677 of file regexp.c.

{
    FuncCallContext *funcctx;
    regexp_matches_ctx *splitctx;
 
    if (SRF_IS_FIRSTCALL())
    {
        text       *pattern = PG_GETARG_TEXT_PP(1);
        text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(2);
        pg_re_flags re_flags;
        MemoryContext oldcontext;
 
        funcctx = SRF_FIRSTCALL_INIT();
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* Determine options */
        parse_re_flags(&re_flags, flags);
        /* User mustn't specify 'g' */
        if (re_flags.glob)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
            /* translator: %s is a SQL function name */
                     errmsg("%s does not support the \"global\" option",
                            "regexp_split_to_table()")));
        /* But we find all the matches anyway */
        re_flags.glob = true;
 
        /* be sure to copy the input string into the multi-call ctx */
        splitctx = setup_regexp_matches(PG_GETARG_TEXT_P_COPY(0), pattern,
                                        &re_flags, 0,
                                        PG_GET_COLLATION(),
                                        false, true, true);
 
        MemoryContextSwitchTo(oldcontext);
        funcctx->user_fctx = (void *) splitctx;
    }
 
    funcctx = SRF_PERCALL_SETUP();
    splitctx = (regexp_matches_ctx *) funcctx->user_fctx;
 
    if (splitctx->next_match <= splitctx->nmatches)
    {
        Datum       result = build_regexp_split_result(splitctx);
 
        splitctx->next_match++;
        SRF_RETURN_NEXT(funcctx, result);
    }
 
    SRF_RETURN_DONE(funcctx);
}

References build_regexp_split_result(), ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, if(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, regexp_matches_ctx::next_match, regexp_matches_ctx::nmatches, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_P_COPY, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, setup_regexp_matches(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and FuncCallContext::user_fctx.

Referenced by regexp_split_to_table_no_flags().

regexp_split_to_table_no_flags()

Datum regexp_split_to_table_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1730 of file regexp.c.

{
    return regexp_split_to_table(fcinfo);
}

References regexp_split_to_table().

regexp_substr()

Datum regexp_substr

(

PG_FUNCTION_ARGS

)

Definition at line 1833 of file regexp.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    text       *pattern = PG_GETARG_TEXT_PP(1);
    int         start = 1;
    int         n = 1;
    text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(4);
    int         subexpr = 0;
    int         so,
                eo,
                pos;
    pg_re_flags re_flags;
    regexp_matches_ctx *matchctx;
 
    /* Collect optional parameters */
    if (PG_NARGS() > 2)
    {
        start = PG_GETARG_INT32(2);
        if (start <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "start", start)));
    }
    if (PG_NARGS() > 3)
    {
        n = PG_GETARG_INT32(3);
        if (n <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "n", n)));
    }
    if (PG_NARGS() > 5)
    {
        subexpr = PG_GETARG_INT32(5);
        if (subexpr < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "subexpr", subexpr)));
    }
 
    /* Determine options */
    parse_re_flags(&re_flags, flags);
    /* User mustn't specify 'g' */
    if (re_flags.glob)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        /* translator: %s is a SQL function name */
                 errmsg("%s does not support the \"global\" option",
                        "regexp_substr()")));
    /* But we find all the matches anyway */
    re_flags.glob = true;
 
    /* Do the matching */
    matchctx = setup_regexp_matches(str, pattern, &re_flags, start - 1,
                                    PG_GET_COLLATION(),
                                    (subexpr > 0),  /* need submatches? */
                                    false, false);
 
    /* When n exceeds matches return NULL (includes case of no matches) */
    if (n > matchctx->nmatches)
        PG_RETURN_NULL();
 
    /* When subexpr exceeds number of subexpressions return NULL */
    if (subexpr > matchctx->npatterns)
        PG_RETURN_NULL();
 
    /* Select the appropriate match position to return */
    pos = (n - 1) * matchctx->npatterns;
    if (subexpr > 0)
        pos += subexpr - 1;
    pos *= 2;
    so = matchctx->match_locs[pos];
    eo = matchctx->match_locs[pos + 1];
 
    if (so < 0 || eo < 0)
        PG_RETURN_NULL();       /* unidentifiable location */
 
    PG_RETURN_DATUM(DirectFunctionCall3(text_substr,
                                        PointerGetDatum(matchctx->orig_str),
                                        Int32GetDatum(so + 1),
                                        Int32GetDatum(eo - so)));
}

References DirectFunctionCall3, ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, if(), Int32GetDatum(), regexp_matches_ctx::match_locs, regexp_matches_ctx::nmatches, regexp_matches_ctx::npatterns, regexp_matches_ctx::orig_str, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_NARGS, PG_RETURN_DATUM, PG_RETURN_NULL, PointerGetDatum(), setup_regexp_matches(), generate_unaccent_rules::str, and text_substr().

Referenced by regexp_substr_no_flags(), regexp_substr_no_n(), regexp_substr_no_start(), and regexp_substr_no_subexpr().

regexp_substr_no_flags()

Datum regexp_substr_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 1935 of file regexp.c.

{
    return regexp_substr(fcinfo);
}

References regexp_substr().

regexp_substr_no_n()

Datum regexp_substr_no_n

(

PG_FUNCTION_ARGS

)

Definition at line 1928 of file regexp.c.

{
    return regexp_substr(fcinfo);
}

References regexp_substr().

regexp_substr_no_start()

Datum regexp_substr_no_start

(

PG_FUNCTION_ARGS

)

Definition at line 1921 of file regexp.c.

{
    return regexp_substr(fcinfo);
}

References regexp_substr().

regexp_substr_no_subexpr()

Datum regexp_substr_no_subexpr

(

PG_FUNCTION_ARGS

)

Definition at line 1942 of file regexp.c.

{
    return regexp_substr(fcinfo);
}

References regexp_substr().

setup_regexp_matches()

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  )

static

Definition at line 1417 of file regexp.c.

{
    regexp_matches_ctx *matchctx = palloc0(sizeof(regexp_matches_ctx));
    int         eml = pg_database_encoding_max_length();
    int         orig_len;
    pg_wchar   *wide_str;
    int         wide_len;
    int         cflags;
    regex_t    *cpattern;
    regmatch_t *pmatch;
    int         pmatch_len;
    int         array_len;
    int         array_idx;
    int         prev_match_end;
    int         prev_valid_match_end;
    int         maxlen = 0;     /* largest fetch length in characters */
 
    /* save original string --- we'll extract result substrings from it */
    matchctx->orig_str = orig_str;
 
    /* convert string to pg_wchar form for matching */
    orig_len = VARSIZE_ANY_EXHDR(orig_str);
    wide_str = (pg_wchar *) palloc(sizeof(pg_wchar) * (orig_len + 1));
    wide_len = pg_mb2wchar_with_len(VARDATA_ANY(orig_str), wide_str, orig_len);
 
    /* set up the compiled pattern */
    cflags = re_flags->cflags;
    if (!use_subpatterns)
        cflags |= REG_NOSUB;
    cpattern = RE_compile_and_cache(pattern, cflags, collation);
 
    /* do we want to remember subpatterns? */
    if (use_subpatterns && cpattern->re_nsub > 0)
    {
        matchctx->npatterns = cpattern->re_nsub;
        pmatch_len = cpattern->re_nsub + 1;
    }
    else
    {
        use_subpatterns = false;
        matchctx->npatterns = 1;
        pmatch_len = 1;
    }
 
    /* temporary output space for RE package */
    pmatch = palloc(sizeof(regmatch_t) * pmatch_len);
 
    /*
     * the real output space (grown dynamically if needed)
     *
     * use values 2^n-1, not 2^n, so that we hit the limit at 2^28-1 rather
     * than at 2^27
     */
    array_len = re_flags->glob ? 255 : 31;
    matchctx->match_locs = (int *) palloc(sizeof(int) * array_len);
    array_idx = 0;
 
    /* search for the pattern, perhaps repeatedly */
    prev_match_end = 0;
    prev_valid_match_end = 0;
    while (RE_wchar_execute(cpattern, wide_str, wide_len, start_search,
                            pmatch_len, pmatch))
    {
        /*
         * If requested, ignore degenerate matches, which are zero-length
         * matches occurring at the start or end of a string or just after a
         * previous match.
         */
        if (!ignore_degenerate ||
            (pmatch[0].rm_so < wide_len &&
             pmatch[0].rm_eo > prev_match_end))
        {
            /* enlarge output space if needed */
            while (array_idx + matchctx->npatterns * 2 + 1 > array_len)
            {
                array_len += array_len + 1; /* 2^n-1 => 2^(n+1)-1 */
                if (array_len > MaxAllocSize / sizeof(int))
                    ereport(ERROR,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                             errmsg("too many regular expression matches")));
                matchctx->match_locs = (int *) repalloc(matchctx->match_locs,
                                                        sizeof(int) * array_len);
            }
 
            /* save this match's locations */
            if (use_subpatterns)
            {
                int         i;
 
                for (i = 1; i <= matchctx->npatterns; i++)
                {
                    int         so = pmatch[i].rm_so;
                    int         eo = pmatch[i].rm_eo;
 
                    matchctx->match_locs[array_idx++] = so;
                    matchctx->match_locs[array_idx++] = eo;
                    if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
                        maxlen = (eo - so);
                }
            }
            else
            {
                int         so = pmatch[0].rm_so;
                int         eo = pmatch[0].rm_eo;
 
                matchctx->match_locs[array_idx++] = so;
                matchctx->match_locs[array_idx++] = eo;
                if (so >= 0 && eo >= 0 && (eo - so) > maxlen)
                    maxlen = (eo - so);
            }
            matchctx->nmatches++;
 
            /*
             * check length of unmatched portion between end of previous valid
             * (nondegenerate, or degenerate but not ignored) match and start
             * of current one
             */
            if (fetching_unmatched &&
                pmatch[0].rm_so >= 0 &&
                (pmatch[0].rm_so - prev_valid_match_end) > maxlen)
                maxlen = (pmatch[0].rm_so - prev_valid_match_end);
            prev_valid_match_end = pmatch[0].rm_eo;
        }
        prev_match_end = pmatch[0].rm_eo;
 
        /* if not glob, stop after one match */
        if (!re_flags->glob)
            break;
 
        /*
         * Advance search position.  Normally we start the next search at the
         * end of the previous match; but if the match was of zero length, we
         * have to advance by one character, or we'd just find the same match
         * again.
         */
        start_search = prev_match_end;
        if (pmatch[0].rm_so == pmatch[0].rm_eo)
            start_search++;
        if (start_search > wide_len)
            break;
    }
 
    /*
     * check length of unmatched portion between end of last match and end of
     * input string
     */
    if (fetching_unmatched &&
        (wide_len - prev_valid_match_end) > maxlen)
        maxlen = (wide_len - prev_valid_match_end);
 
    /*
     * Keep a note of the end position of the string for the benefit of
     * splitting code.
     */
    matchctx->match_locs[array_idx] = wide_len;
 
    if (eml > 1)
    {
        int64       maxsiz = eml * (int64) maxlen;
        int         conv_bufsiz;
 
        /*
         * Make the conversion buffer large enough for any substring of
         * interest.
         *
         * Worst case: assume we need the maximum size (maxlen*eml), but take
         * advantage of the fact that the original string length in bytes is
         * an upper bound on the byte length of any fetched substring (and we
         * know that len+1 is safe to allocate because the varlena header is
         * longer than 1 byte).
         */
        if (maxsiz > orig_len)
            conv_bufsiz = orig_len + 1;
        else
            conv_bufsiz = maxsiz + 1;   /* safe since maxsiz < 2^30 */
 
        matchctx->conv_buf = palloc(conv_bufsiz);
        matchctx->conv_bufsiz = conv_bufsiz;
        matchctx->wide_str = wide_str;
    }
    else
    {
        /* No need to keep the wide string if we're in a single-byte charset. */
        pfree(wide_str);
        matchctx->wide_str = NULL;
        matchctx->conv_buf = NULL;
        matchctx->conv_bufsiz = 0;
    }
 
    /* Clean up temp storage */
    pfree(pmatch);
 
    return matchctx;
}

References pg_re_flags::cflags, regexp_matches_ctx::conv_buf, regexp_matches_ctx::conv_bufsiz, ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, i, regexp_matches_ctx::match_locs, MaxAllocSize, regexp_matches_ctx::nmatches, regexp_matches_ctx::npatterns, regexp_matches_ctx::orig_str, palloc(), palloc0(), pfree(), pg_database_encoding_max_length(), pg_mb2wchar_with_len(), RE_compile_and_cache(), regex_t::re_nsub, RE_wchar_execute(), REG_NOSUB, repalloc(), regmatch_t::rm_eo, regmatch_t::rm_so, VARDATA_ANY, VARSIZE_ANY_EXHDR, and regexp_matches_ctx::wide_str.

Referenced by regexp_count(), regexp_instr(), regexp_match(), regexp_matches(), regexp_split_to_array(), regexp_split_to_table(), and regexp_substr().

similar_escape()

Datum similar_escape

(

PG_FUNCTION_ARGS

)

Definition at line 1041 of file regexp.c.

{
    text       *pat_text;
    text       *esc_text;
    text       *result;
 
    /* This function is not strict, so must test explicitly */
    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();
    pat_text = PG_GETARG_TEXT_PP(0);
 
    if (PG_ARGISNULL(1))
        esc_text = NULL;        /* use default escape character */
    else
        esc_text = PG_GETARG_TEXT_PP(1);
 
    result = similar_escape_internal(pat_text, esc_text);
 
    PG_RETURN_TEXT_P(result);
}

References PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and similar_escape_internal().

similar_escape_internal()

static text* similar_escape_internal ( text *  pat_text, text *  esc_text  )

static

Definition at line 768 of file regexp.c.

{
    text       *result;
    char       *p,
               *e,
               *r;
    int         plen,
                elen;
    bool        afterescape = false;
    bool        incharclass = false;
    int         nquotes = 0;
 
    p = VARDATA_ANY(pat_text);
    plen = VARSIZE_ANY_EXHDR(pat_text);
    if (esc_text == NULL)
    {
        /* No ESCAPE clause provided; default to backslash as escape */
        e = "\\";
        elen = 1;
    }
    else
    {
        e = VARDATA_ANY(esc_text);
        elen = VARSIZE_ANY_EXHDR(esc_text);
        if (elen == 0)
            e = NULL;           /* no escape character */
        else if (elen > 1)
        {
            int         escape_mblen = pg_mbstrlen_with_len(e, elen);
 
            if (escape_mblen > 1)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
                         errmsg("invalid escape string"),
                         errhint("Escape string must be empty or one character.")));
        }
    }
 
    /*----------
     * We surround the transformed input string with
     *          ^(?: ... )$
     * which requires some explanation.  We need "^" and "$" to force
     * the pattern to match the entire input string as per the SQL spec.
     * The "(?:" and ")" are a non-capturing set of parens; we have to have
     * parens in case the string contains "|", else the "^" and "$" will
     * be bound into the first and last alternatives which is not what we
     * want, and the parens must be non capturing because we don't want them
     * to count when selecting output for SUBSTRING.
     *
     * When the pattern is divided into three parts by escape-double-quotes,
     * what we emit is
     *          ^(?:part1){1,1}?(part2){1,1}(?:part3)$
     * which requires even more explanation.  The "{1,1}?" on part1 makes it
     * non-greedy so that it will match the smallest possible amount of text
     * not the largest, as required by SQL.  The plain parens around part2
     * are capturing parens so that that part is what controls the result of
     * SUBSTRING.  The "{1,1}" forces part2 to be greedy, so that it matches
     * the largest possible amount of text; hence part3 must match the
     * smallest amount of text, as required by SQL.  We don't need an explicit
     * greediness marker on part3.  Note that this also confines the effects
     * of any "|" characters to the respective part, which is what we want.
     *
     * The SQL spec says that SUBSTRING's pattern must contain exactly two
     * escape-double-quotes, but we only complain if there's more than two.
     * With none, we act as though part1 and part3 are empty; with one, we
     * act as though part3 is empty.  Both behaviors fall out of omitting
     * the relevant part separators in the above expansion.  If the result
     * of this function is used in a plain regexp match (SIMILAR TO), the
     * escape-double-quotes have no effect on the match behavior.
     *----------
     */
 
    /*
     * We need room for the prefix/postfix and part separators, plus as many
     * as 3 output bytes per input byte; since the input is at most 1GB this
     * can't overflow size_t.
     */
    result = (text *) palloc(VARHDRSZ + 23 + 3 * (size_t) plen);
    r = VARDATA(result);
 
    *r++ = '^';
    *r++ = '(';
    *r++ = '?';
    *r++ = ':';
 
    while (plen > 0)
    {
        char        pchar = *p;
 
        /*
         * If both the escape character and the current character from the
         * pattern are multi-byte, we need to take the slow path.
         *
         * But if one of them is single-byte, we can process the pattern one
         * byte at a time, ignoring multi-byte characters.  (This works
         * because all server-encodings have the property that a valid
         * multi-byte character representation cannot contain the
         * representation of a valid single-byte character.)
         */
 
        if (elen > 1)
        {
            int         mblen = pg_mblen(p);
 
            if (mblen > 1)
            {
                /* slow, multi-byte path */
                if (afterescape)
                {
                    *r++ = '\\';
                    memcpy(r, p, mblen);
                    r += mblen;
                    afterescape = false;
                }
                else if (e && elen == mblen && memcmp(e, p, mblen) == 0)
                {
                    /* SQL escape character; do not send to output */
                    afterescape = true;
                }
                else
                {
                    /*
                     * We know it's a multi-byte character, so we don't need
                     * to do all the comparisons to single-byte characters
                     * that we do below.
                     */
                    memcpy(r, p, mblen);
                    r += mblen;
                }
 
                p += mblen;
                plen -= mblen;
 
                continue;
            }
        }
 
        /* fast path */
        if (afterescape)
        {
            if (pchar == '"' && !incharclass)   /* escape-double-quote? */
            {
                /* emit appropriate part separator, per notes above */
                if (nquotes == 0)
                {
                    *r++ = ')';
                    *r++ = '{';
                    *r++ = '1';
                    *r++ = ',';
                    *r++ = '1';
                    *r++ = '}';
                    *r++ = '?';
                    *r++ = '(';
                }
                else if (nquotes == 1)
                {
                    *r++ = ')';
                    *r++ = '{';
                    *r++ = '1';
                    *r++ = ',';
                    *r++ = '1';
                    *r++ = '}';
                    *r++ = '(';
                    *r++ = '?';
                    *r++ = ':';
                }
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_USE_OF_ESCAPE_CHARACTER),
                             errmsg("SQL regular expression may not contain more than two escape-double-quote separators")));
                nquotes++;
            }
            else
            {
                /*
                 * We allow any character at all to be escaped; notably, this
                 * allows access to POSIX character-class escapes such as
                 * "\d".  The SQL spec is considerably more restrictive.
                 */
                *r++ = '\\';
                *r++ = pchar;
            }
            afterescape = false;
        }
        else if (e && pchar == *e)
        {
            /* SQL escape character; do not send to output */
            afterescape = true;
        }
        else if (incharclass)
        {
            if (pchar == '\\')
                *r++ = '\\';
            *r++ = pchar;
            if (pchar == ']')
                incharclass = false;
        }
        else if (pchar == '[')
        {
            *r++ = pchar;
            incharclass = true;
        }
        else if (pchar == '%')
        {
            *r++ = '.';
            *r++ = '*';
        }
        else if (pchar == '_')
            *r++ = '.';
        else if (pchar == '(')
        {
            /* convert to non-capturing parenthesis */
            *r++ = '(';
            *r++ = '?';
            *r++ = ':';
        }
        else if (pchar == '\\' || pchar == '.' ||
                 pchar == '^' || pchar == '$')
        {
            *r++ = '\\';
            *r++ = pchar;
        }
        else
            *r++ = pchar;
        p++, plen--;
    }
 
    *r++ = ')';
    *r++ = '$';
 
    SET_VARSIZE(result, r - ((char *) result));
 
    return result;
}

References ereport, errcode(), errhint(), errmsg(), ERROR, palloc(), pg_mblen(), pg_mbstrlen_with_len(), SET_VARSIZE, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

Referenced by similar_escape(), similar_to_escape_1(), and similar_to_escape_2().

similar_to_escape_1()

Datum similar_to_escape_1

(

PG_FUNCTION_ARGS

)

Definition at line 1023 of file regexp.c.

{
    text       *pat_text = PG_GETARG_TEXT_PP(0);
    text       *result;
 
    result = similar_escape_internal(pat_text, NULL);
 
    PG_RETURN_TEXT_P(result);
}

References PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and similar_escape_internal().

similar_to_escape_2()

Datum similar_to_escape_2

(

PG_FUNCTION_ARGS

)

Definition at line 1007 of file regexp.c.

{
    text       *pat_text = PG_GETARG_TEXT_PP(0);
    text       *esc_text = PG_GETARG_TEXT_PP(1);
    text       *result;
 
    result = similar_escape_internal(pat_text, esc_text);
 
    PG_RETURN_TEXT_P(result);
}

References PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and similar_escape_internal().

texticregexeq()

Datum texticregexeq

(

PG_FUNCTION_ARGS

)

Definition at line 551 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(RE_compile_and_execute(p,
                                          VARDATA_ANY(s),
                                          VARSIZE_ANY_EXHDR(s),
                                          REG_ADVANCED | REG_ICASE,
                                          PG_GET_COLLATION(),
                                          0, NULL));
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), REG_ADVANCED, REG_ICASE, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

texticregexne()

Datum texticregexne

(

PG_FUNCTION_ARGS

)

Definition at line 565 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(!RE_compile_and_execute(p,
                                           VARDATA_ANY(s),
                                           VARSIZE_ANY_EXHDR(s),
                                           REG_ADVANCED | REG_ICASE,
                                           PG_GET_COLLATION(),
                                           0, NULL));
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), REG_ADVANCED, REG_ICASE, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

textregexeq()

Datum textregexeq

(

PG_FUNCTION_ARGS

)

Definition at line 488 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(RE_compile_and_execute(p,
                                          VARDATA_ANY(s),
                                          VARSIZE_ANY_EXHDR(s),
                                          REG_ADVANCED,
                                          PG_GET_COLLATION(),
                                          0, NULL));
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), REG_ADVANCED, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

textregexne()

Datum textregexne

(

PG_FUNCTION_ARGS

)

Definition at line 502 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_BOOL(!RE_compile_and_execute(p,
                                           VARDATA_ANY(s),
                                           VARSIZE_ANY_EXHDR(s),
                                           REG_ADVANCED,
                                           PG_GET_COLLATION(),
                                           0, NULL));
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, RE_compile_and_execute(), REG_ADVANCED, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

textregexreplace()

Datum textregexreplace

(

PG_FUNCTION_ARGS

)

Definition at line 659 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
    text       *r = PG_GETARG_TEXT_PP(2);
    text       *opt = PG_GETARG_TEXT_PP(3);
    pg_re_flags flags;
 
    /*
     * regexp_replace() with four arguments will be preferentially resolved as
     * this form when the fourth argument is of type UNKNOWN.  However, the
     * user might have intended to call textregexreplace_extended_no_n.  If we
     * see flags that look like an integer, emit the same error that
     * parse_re_flags would, but add a HINT about how to fix it.
     */
    if (VARSIZE_ANY_EXHDR(opt) > 0)
    {
        char       *opt_p = VARDATA_ANY(opt);
 
        if (*opt_p >= '0' && *opt_p <= '9')
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid regular expression option: \"%.*s\"",
                            pg_mblen(opt_p), opt_p),
                     errhint("If you meant to use regexp_replace() with a start parameter, cast the fourth argument to integer explicitly.")));
    }
 
    parse_re_flags(&flags, opt);
 
    PG_RETURN_TEXT_P(replace_text_regexp(s, p, r,
                                         flags.cflags, PG_GET_COLLATION(),
                                         0, flags.glob ? 0 : 1));
}

References pg_re_flags::cflags, ereport, errcode(), errhint(), errmsg(), ERROR, pg_re_flags::glob, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, pg_mblen(), PG_RETURN_TEXT_P, replace_text_regexp(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by execute_extension_script().

textregexreplace_extended()

Datum textregexreplace_extended

(

PG_FUNCTION_ARGS

)

Definition at line 700 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
    text       *r = PG_GETARG_TEXT_PP(2);
    int         start = 1;
    int         n = 1;
    text       *flags = PG_GETARG_TEXT_PP_IF_EXISTS(5);
    pg_re_flags re_flags;
 
    /* Collect optional parameters */
    if (PG_NARGS() > 3)
    {
        start = PG_GETARG_INT32(3);
        if (start <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "start", start)));
    }
    if (PG_NARGS() > 4)
    {
        n = PG_GETARG_INT32(4);
        if (n < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid value for parameter \"%s\": %d",
                            "n", n)));
    }
 
    /* Determine options */
    parse_re_flags(&re_flags, flags);
 
    /* If N was not specified, deduce it from the 'g' flag */
    if (PG_NARGS() <= 4)
        n = re_flags.glob ? 0 : 1;
 
    /* Do the replacement(s) */
    PG_RETURN_TEXT_P(replace_text_regexp(s, p, r,
                                         re_flags.cflags, PG_GET_COLLATION(),
                                         start - 1, n));
}

References pg_re_flags::cflags, ereport, errcode(), errmsg(), ERROR, pg_re_flags::glob, parse_re_flags(), PG_GET_COLLATION, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_GETARG_TEXT_PP_IF_EXISTS, PG_NARGS, PG_RETURN_TEXT_P, and replace_text_regexp().

Referenced by textregexreplace_extended_no_flags(), and textregexreplace_extended_no_n().

textregexreplace_extended_no_flags()

Datum textregexreplace_extended_no_flags

(

PG_FUNCTION_ARGS

)

Definition at line 752 of file regexp.c.

{
    return textregexreplace_extended(fcinfo);
}

References textregexreplace_extended().

textregexreplace_extended_no_n()

Datum textregexreplace_extended_no_n

(

PG_FUNCTION_ARGS

)

Definition at line 745 of file regexp.c.

{
    return textregexreplace_extended(fcinfo);
}

References textregexreplace_extended().

textregexreplace_noopt()

Datum textregexreplace_noopt

(

PG_FUNCTION_ARGS

)

Definition at line 643 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
    text       *r = PG_GETARG_TEXT_PP(2);
 
    PG_RETURN_TEXT_P(replace_text_regexp(s, p, r,
                                         REG_ADVANCED, PG_GET_COLLATION(),
                                         0, 1));
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, REG_ADVANCED, and replace_text_regexp().

textregexsubstr()

Datum textregexsubstr

(

PG_FUNCTION_ARGS

)

Definition at line 584 of file regexp.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    text       *p = PG_GETARG_TEXT_PP(1);
    regex_t    *re;
    regmatch_t  pmatch[2];
    int         so,
                eo;
 
    /* Compile RE */
    re = RE_compile_and_cache(p, REG_ADVANCED, PG_GET_COLLATION());
 
    /*
     * We pass two regmatch_t structs to get info about the overall match and
     * the match for the first parenthesized subexpression (if any). If there
     * is a parenthesized subexpression, we return what it matched; else
     * return what the whole regexp matched.
     */
    if (!RE_execute(re,
                    VARDATA_ANY(s), VARSIZE_ANY_EXHDR(s),
                    2, pmatch))
        PG_RETURN_NULL();       /* definitely no match */
 
    if (re->re_nsub > 0)
    {
        /* has parenthesized subexpressions, use the first one */
        so = pmatch[1].rm_so;
        eo = pmatch[1].rm_eo;
    }
    else
    {
        /* no parenthesized subexpression, use whole match */
        so = pmatch[0].rm_so;
        eo = pmatch[0].rm_eo;
    }
 
    /*
     * It is possible to have a match to the whole pattern but no match for a
     * subexpression; for example 'foo(bar)?' is considered to match 'foo' but
     * there is no subexpression match.  So this extra test for match failure
     * is not redundant.
     */
    if (so < 0 || eo < 0)
        PG_RETURN_NULL();
 
    return DirectFunctionCall3(text_substr,
                               PointerGetDatum(s),
                               Int32GetDatum(so + 1),
                               Int32GetDatum(eo - so));
}

References DirectFunctionCall3, Int32GetDatum(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PointerGetDatum(), RE_compile_and_cache(), RE_execute(), regex_t::re_nsub, REG_ADVANCED, regmatch_t::rm_eo, regmatch_t::rm_so, text_substr(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Variable Documentation

num_res

int num_res = 0

static

Definition at line 113 of file regexp.c.

Referenced by RE_compile_and_cache().

re_array

cached_re_str re_array[MAX_CACHED_RES]

static

Definition at line 114 of file regexp.c.

Referenced by RE_compile_and_cache().

RegexpCacheMemoryContext

MemoryContext RegexpCacheMemoryContext

static

Definition at line 100 of file regexp.c.

Referenced by RE_compile_and_cache().