varlena.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <limits.h>
#include "access/detoast.h"
#include "access/toast_compression.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "common/int.h"
#include "common/unicode_category.h"
#include "common/unicode_norm.h"
#include "common/unicode_version.h"
#include "funcapi.h"
#include "lib/hyperloglog.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/execnodes.h"
#include "parser/scansup.h"
#include "port/pg_bswap.h"
#include "regex/regex.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/pg_locale.h"
#include "utils/sortsupport.h"
#include "utils/varlena.h"
#include "levenshtein.c"

Include dependency graph for varlena.c:

Go to the source code of this file.

Data Structures
struct	TextPositionState
struct	VarStringSortSupport
struct	SplitTextOutputData

Macros
#define	TEXTBUFLEN   1024
#define	DatumGetVarStringP(X)   ((VarString *) PG_DETOAST_DATUM(X))
#define	DatumGetVarStringPP(X)   ((VarString *) PG_DETOAST_DATUM_PACKED(X))
#define	CmpCall(cmpfunc)
#define	TEXT_FORMAT_FLAG_MINUS   0x0001 /* is minus flag present? */
#define	ADVANCE_PARSE_POINTER(ptr, end_ptr)
#define	LEVENSHTEIN_LESS_EQUAL

Typedefs
typedef struct varlena	VarString

Functions
static int	varstrfastcmp_c (Datum x, Datum y, SortSupport ssup)
static int	bpcharfastcmp_c (Datum x, Datum y, SortSupport ssup)
static int	namefastcmp_c (Datum x, Datum y, SortSupport ssup)
static int	varlenafastcmp_locale (Datum x, Datum y, SortSupport ssup)
static int	namefastcmp_locale (Datum x, Datum y, SortSupport ssup)
static int	varstrfastcmp_locale (char *a1p, int len1, char *a2p, int len2, SortSupport ssup)
static Datum	varstr_abbrev_convert (Datum original, SortSupport ssup)
static bool	varstr_abbrev_abort (int memtupcount, SortSupport ssup)
static int32	text_length (Datum str)
static text *	text_catenate (text *t1, text *t2)
static text *	text_substring (Datum str, int32 start, int32 length, bool length_not_specified)
static text *	text_overlay (text *t1, text *t2, int sp, int sl)
static int	text_position (text *t1, text *t2, Oid collid)
static void	text_position_setup (text *t1, text *t2, Oid collid, TextPositionState *state)
static bool	text_position_next (TextPositionState *state)
static char *	text_position_next_internal (char *start_ptr, TextPositionState *state)
static char *	text_position_get_match_ptr (TextPositionState *state)
static int	text_position_get_match_pos (TextPositionState *state)
static void	text_position_cleanup (TextPositionState *state)
static void	check_collation_set (Oid collid)
static int	text_cmp (text *arg1, text *arg2, Oid collid)
static void	appendStringInfoText (StringInfo str, const text *t)
static bool	split_text (FunctionCallInfo fcinfo, SplitTextOutputData *tstate)
static void	split_text_accum_result (SplitTextOutputData *tstate, text *field_value, text *null_string, Oid collation)
static text *	array_to_text_internal (FunctionCallInfo fcinfo, ArrayType *v, const char *fldsep, const char *null_string)
static StringInfo	makeStringAggState (FunctionCallInfo fcinfo)
static bool	text_format_parse_digits (const char **ptr, const char *end_ptr, int *value)
static const char *	text_format_parse_format (const char *start_ptr, const char *end_ptr, int *argpos, int *widthpos, int *flags, int *width)
static void	text_format_string_conversion (StringInfo buf, char conversion, FmgrInfo *typOutputInfo, Datum value, bool isNull, int flags, int width)
static void	text_format_append_string (StringInfo buf, const char *str, int flags, int width)
text *	cstring_to_text (const char *s)
text *	cstring_to_text_with_len (const char *s, int len)
char *	text_to_cstring (const text *t)
void	text_to_cstring_buffer (const text *src, char *dst, size_t dst_len)
Datum	textin (PG_FUNCTION_ARGS)
Datum	textout (PG_FUNCTION_ARGS)
Datum	textrecv (PG_FUNCTION_ARGS)
Datum	textsend (PG_FUNCTION_ARGS)
Datum	unknownin (PG_FUNCTION_ARGS)
Datum	unknownout (PG_FUNCTION_ARGS)
Datum	unknownrecv (PG_FUNCTION_ARGS)
Datum	unknownsend (PG_FUNCTION_ARGS)
Datum	textlen (PG_FUNCTION_ARGS)
Datum	textoctetlen (PG_FUNCTION_ARGS)
Datum	textcat (PG_FUNCTION_ARGS)
static int	charlen_to_bytelen (const char *p, int n)
Datum	text_substr (PG_FUNCTION_ARGS)
Datum	text_substr_no_len (PG_FUNCTION_ARGS)
Datum	textoverlay (PG_FUNCTION_ARGS)
Datum	textoverlay_no_len (PG_FUNCTION_ARGS)
Datum	textpos (PG_FUNCTION_ARGS)
static void	text_position_reset (TextPositionState *state)
int	varstr_cmp (const char *arg1, int len1, const char *arg2, int len2, Oid collid)
Datum	texteq (PG_FUNCTION_ARGS)
Datum	textne (PG_FUNCTION_ARGS)
Datum	text_lt (PG_FUNCTION_ARGS)
Datum	text_le (PG_FUNCTION_ARGS)
Datum	text_gt (PG_FUNCTION_ARGS)
Datum	text_ge (PG_FUNCTION_ARGS)
Datum	text_starts_with (PG_FUNCTION_ARGS)
Datum	bttextcmp (PG_FUNCTION_ARGS)
Datum	bttextsortsupport (PG_FUNCTION_ARGS)
void	varstr_sortsupport (SortSupport ssup, Oid typid, Oid collid)
Datum	btvarstrequalimage (PG_FUNCTION_ARGS)
Datum	text_larger (PG_FUNCTION_ARGS)
Datum	text_smaller (PG_FUNCTION_ARGS)
Datum	nameeqtext (PG_FUNCTION_ARGS)
Datum	texteqname (PG_FUNCTION_ARGS)
Datum	namenetext (PG_FUNCTION_ARGS)
Datum	textnename (PG_FUNCTION_ARGS)
Datum	btnametextcmp (PG_FUNCTION_ARGS)
Datum	bttextnamecmp (PG_FUNCTION_ARGS)
Datum	namelttext (PG_FUNCTION_ARGS)
Datum	nameletext (PG_FUNCTION_ARGS)
Datum	namegttext (PG_FUNCTION_ARGS)
Datum	namegetext (PG_FUNCTION_ARGS)
Datum	textltname (PG_FUNCTION_ARGS)
Datum	textlename (PG_FUNCTION_ARGS)
Datum	textgtname (PG_FUNCTION_ARGS)
Datum	textgename (PG_FUNCTION_ARGS)
static int	internal_text_pattern_compare (text *arg1, text *arg2)
Datum	text_pattern_lt (PG_FUNCTION_ARGS)
Datum	text_pattern_le (PG_FUNCTION_ARGS)
Datum	text_pattern_ge (PG_FUNCTION_ARGS)
Datum	text_pattern_gt (PG_FUNCTION_ARGS)
Datum	bttext_pattern_cmp (PG_FUNCTION_ARGS)
Datum	bttext_pattern_sortsupport (PG_FUNCTION_ARGS)
Datum	text_name (PG_FUNCTION_ARGS)
Datum	name_text (PG_FUNCTION_ARGS)
List *	textToQualifiedNameList (text *textval)
bool	SplitIdentifierString (char *rawstring, char separator, List **namelist)
bool	SplitDirectoriesString (char *rawstring, char separator, List **namelist)
bool	SplitGUCList (char *rawstring, char separator, List **namelist)
Datum	replace_text (PG_FUNCTION_ARGS)
static int	check_replace_text_has_escape (const text *replace_text)
static void	appendStringInfoRegexpSubstr (StringInfo str, text *replace_text, regmatch_t *pmatch, char *start_ptr, int data_pos)
text *	replace_text_regexp (text *src_text, text *pattern_text, text *replace_text, int cflags, Oid collation, int search_start, int n)
Datum	split_part (PG_FUNCTION_ARGS)
static bool	text_isequal (text *txt1, text *txt2, Oid collid)
Datum	text_to_array (PG_FUNCTION_ARGS)
Datum	text_to_array_null (PG_FUNCTION_ARGS)
Datum	text_to_table (PG_FUNCTION_ARGS)
Datum	text_to_table_null (PG_FUNCTION_ARGS)
Datum	array_to_text (PG_FUNCTION_ARGS)
Datum	array_to_text_null (PG_FUNCTION_ARGS)
static text *	convert_to_base (uint64 value, int base)
Datum	to_bin32 (PG_FUNCTION_ARGS)
Datum	to_bin64 (PG_FUNCTION_ARGS)
Datum	to_oct32 (PG_FUNCTION_ARGS)
Datum	to_oct64 (PG_FUNCTION_ARGS)
Datum	to_hex32 (PG_FUNCTION_ARGS)
Datum	to_hex64 (PG_FUNCTION_ARGS)
Datum	pg_column_size (PG_FUNCTION_ARGS)
Datum	pg_column_compression (PG_FUNCTION_ARGS)
Datum	pg_column_toast_chunk_id (PG_FUNCTION_ARGS)
Datum	string_agg_transfn (PG_FUNCTION_ARGS)
Datum	string_agg_combine (PG_FUNCTION_ARGS)
Datum	string_agg_serialize (PG_FUNCTION_ARGS)
Datum	string_agg_deserialize (PG_FUNCTION_ARGS)
Datum	string_agg_finalfn (PG_FUNCTION_ARGS)
static FmgrInfo *	build_concat_foutcache (FunctionCallInfo fcinfo, int argidx)
static text *	concat_internal (const char *sepstr, int argidx, FunctionCallInfo fcinfo)
Datum	text_concat (PG_FUNCTION_ARGS)
Datum	text_concat_ws (PG_FUNCTION_ARGS)
Datum	text_left (PG_FUNCTION_ARGS)
Datum	text_right (PG_FUNCTION_ARGS)
Datum	text_reverse (PG_FUNCTION_ARGS)
Datum	text_format (PG_FUNCTION_ARGS)
Datum	text_format_nv (PG_FUNCTION_ARGS)
static bool	rest_of_char_same (const char *s1, const char *s2, int len)
void	initClosestMatch (ClosestMatchState *state, const char *source, int max_d)
void	updateClosestMatch (ClosestMatchState *state, const char *candidate)
const char *	getClosestMatch (ClosestMatchState *state)
static UnicodeNormalizationForm	unicode_norm_form_from_string (const char *formstr)
Datum	unicode_version (PG_FUNCTION_ARGS)
Datum	icu_unicode_version (PG_FUNCTION_ARGS)
Datum	unicode_assigned (PG_FUNCTION_ARGS)
Datum	unicode_normalize_func (PG_FUNCTION_ARGS)
Datum	unicode_is_normalized (PG_FUNCTION_ARGS)
static bool	isxdigits_n (const char *instr, size_t n)
static unsigned int	hexval (unsigned char c)
static unsigned int	hexval_n (const char *instr, size_t n)
Datum	unistr (PG_FUNCTION_ARGS)

Macro Definition Documentation

ADVANCE_PARSE_POINTER

#define ADVANCE_PARSE_POINTER	(		ptr,
			end_ptr
	)

Value:

    do { \
        if (++(ptr) >= (end_ptr)) \
            ereport(ERROR, \
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
                     errmsg("unterminated format() type specifier"), \
                     errhint("For a single \"%%\" use \"%%%%\"."))); \
    } while (0)

Definition at line 4721 of file varlena.c.

CmpCall

#define CmpCall

(

cmpfunc

)

Value:

    DatumGetInt32(DirectFunctionCall2Coll(cmpfunc, \
                                          PG_GET_COLLATION(), \
                                          PG_GETARG_DATUM(0), \
                                          PG_GETARG_DATUM(1)))

Definition at line 2458 of file varlena.c.

DatumGetVarStringP

#define DatumGetVarStringP

(

X

)

((VarString *) PG_DETOAST_DATUM(X))

Definition at line 119 of file varlena.c.

DatumGetVarStringPP

#define DatumGetVarStringPP

(

X

)

((VarString *) PG_DETOAST_DATUM_PACKED(X))

Definition at line 120 of file varlena.c.

LEVENSHTEIN_LESS_EQUAL

#define LEVENSHTEIN_LESS_EQUAL

Definition at line 5261 of file varlena.c.

TEXT_FORMAT_FLAG_MINUS

#define TEXT_FORMAT_FLAG_MINUS   0x0001 /* is minus flag present? */

Definition at line 4719 of file varlena.c.

TEXTBUFLEN

#define TEXTBUFLEN   1024

Definition at line 117 of file varlena.c.

Typedef Documentation

VarString

typedef struct varlena VarString

Definition at line 45 of file varlena.c.

Function Documentation

appendStringInfoRegexpSubstr()

static void appendStringInfoRegexpSubstr ( StringInfo  str, text *  replace_text, regmatch_t *  pmatch, char *  start_ptr, int  data_pos  )

static

Definition at line 3202 of file varlena.c.

{
    const char *p = VARDATA_ANY(replace_text);
    const char *p_end = p + VARSIZE_ANY_EXHDR(replace_text);
 
    while (p < p_end)
    {
        const char *chunk_start = p;
        int         so;
        int         eo;
 
        /* Find next escape char, if any. */
        p = memchr(p, '\\', p_end - p);
        if (p == NULL)
            p = p_end;
 
        /* Copy the text we just scanned over, if any. */
        if (p > chunk_start)
            appendBinaryStringInfo(str, chunk_start, p - chunk_start);
 
        /* Done if at end of string, else advance over escape char. */
        if (p >= p_end)
            break;
        p++;
 
        if (p >= p_end)
        {
            /* Escape at very end of input.  Treat same as unexpected char */
            appendStringInfoChar(str, '\\');
            break;
        }
 
        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++;
        }
        else if (*p == '&')
        {
            /* Use the entire matched string. */
            so = pmatch[0].rm_so;
            eo = pmatch[0].rm_eo;
            p++;
        }
        else if (*p == '\\')
        {
            /* \\ means transfer one \ to output. */
            appendStringInfoChar(str, '\\');
            p++;
            continue;
        }
        else
        {
            /*
             * If escape char is not followed by any expected char, just treat
             * it as ordinary data to copy.  (XXX would it be better to throw
             * an error?)
             */
            appendStringInfoChar(str, '\\');
            continue;
        }
 
        if (so >= 0 && eo >= 0)
        {
            /*
             * Copy the text that is back reference of regexp.  Note so and eo
             * are counted in characters not bytes.
             */
            char       *chunk_start;
            int         chunk_len;
 
            Assert(so >= data_pos);
            chunk_start = start_ptr;
            chunk_start += charlen_to_bytelen(chunk_start, so - data_pos);
            chunk_len = charlen_to_bytelen(chunk_start, eo - so);
            appendBinaryStringInfo(str, chunk_start, chunk_len);
        }
    }
}

References appendBinaryStringInfo(), appendStringInfoChar(), Assert(), charlen_to_bytelen(), idx(), replace_text(), str, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by replace_text_regexp().

appendStringInfoText()

static void appendStringInfoText ( StringInfo  str, const text *  t  )

static

Definition at line 3078 of file varlena.c.

{
    appendBinaryStringInfo(str, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
}

References appendBinaryStringInfo(), str, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by replace_text(), replace_text_regexp(), string_agg_transfn(), xmlcomment(), and XmlTableGetValue().

array_to_text()

Datum array_to_text

(

PG_FUNCTION_ARGS

)

Definition at line 3862 of file varlena.c.

{
    ArrayType  *v = PG_GETARG_ARRAYTYPE_P(0);
    char       *fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
 
    PG_RETURN_TEXT_P(array_to_text_internal(fcinfo, v, fldsep, NULL));
}

References array_to_text_internal(), PG_GETARG_ARRAYTYPE_P, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and text_to_cstring().

array_to_text_internal()

static text * array_to_text_internal ( FunctionCallInfo  fcinfo, ArrayType *  v, const char *  fldsep, const char *  null_string  )

static

Definition at line 3904 of file varlena.c.

{
    text       *result;
    int         nitems,
               *dims,
                ndims;
    Oid         element_type;
    int         typlen;
    bool        typbyval;
    char        typalign;
    StringInfoData buf;
    bool        printed = false;
    char       *p;
    bits8      *bitmap;
    int         bitmask;
    int         i;
    ArrayMetaState *my_extra;
 
    ndims = ARR_NDIM(v);
    dims = ARR_DIMS(v);
    nitems = ArrayGetNItems(ndims, dims);
 
    /* if there are no elements, return an empty string */
    if (nitems == 0)
        return cstring_to_text_with_len("", 0);
 
    element_type = ARR_ELEMTYPE(v);
    initStringInfo(&buf);
 
    /*
     * We arrange to look up info about element type, including its output
     * conversion proc, only once per series of calls, assuming the element
     * type doesn't change underneath us.
     */
    my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
    if (my_extra == NULL)
    {
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(ArrayMetaState));
        my_extra = (ArrayMetaState *) fcinfo->flinfo->fn_extra;
        my_extra->element_type = ~element_type;
    }
 
    if (my_extra->element_type != element_type)
    {
        /*
         * Get info about element type, including its output conversion proc
         */
        get_type_io_data(element_type, IOFunc_output,
                         &my_extra->typlen, &my_extra->typbyval,
                         &my_extra->typalign, &my_extra->typdelim,
                         &my_extra->typioparam, &my_extra->typiofunc);
        fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc,
                      fcinfo->flinfo->fn_mcxt);
        my_extra->element_type = element_type;
    }
    typlen = my_extra->typlen;
    typbyval = my_extra->typbyval;
    typalign = my_extra->typalign;
 
    p = ARR_DATA_PTR(v);
    bitmap = ARR_NULLBITMAP(v);
    bitmask = 1;
 
    for (i = 0; i < nitems; i++)
    {
        Datum       itemvalue;
        char       *value;
 
        /* Get source element, checking for NULL */
        if (bitmap && (*bitmap & bitmask) == 0)
        {
            /* if null_string is NULL, we just ignore null elements */
            if (null_string != NULL)
            {
                if (printed)
                    appendStringInfo(&buf, "%s%s", fldsep, null_string);
                else
                    appendStringInfoString(&buf, null_string);
                printed = true;
            }
        }
        else
        {
            itemvalue = fetch_att(p, typbyval, typlen);
 
            value = OutputFunctionCall(&my_extra->proc, itemvalue);
 
            if (printed)
                appendStringInfo(&buf, "%s%s", fldsep, value);
            else
                appendStringInfoString(&buf, value);
            printed = true;
 
            p = att_addlength_pointer(p, typlen, p);
            p = (char *) att_align_nominal(p, typalign);
        }
 
        /* advance bitmap pointer if any */
        if (bitmap)
        {
            bitmask <<= 1;
            if (bitmask == 0x100)
            {
                bitmap++;
                bitmask = 1;
            }
        }
    }
 
    result = cstring_to_text_with_len(buf.data, buf.len);
    pfree(buf.data);
 
    return result;
}

References appendStringInfo(), appendStringInfoString(), ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_NDIM, ARR_NULLBITMAP, ArrayGetNItems(), att_addlength_pointer, att_align_nominal, buf, cstring_to_text_with_len(), ArrayMetaState::element_type, fetch_att(), FunctionCallInfoBaseData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, get_type_io_data(), i, if(), initStringInfo(), IOFunc_output, MemoryContextAlloc(), nitems, OutputFunctionCall(), pfree(), ArrayMetaState::proc, typalign, ArrayMetaState::typalign, ArrayMetaState::typbyval, ArrayMetaState::typdelim, ArrayMetaState::typiofunc, ArrayMetaState::typioparam, ArrayMetaState::typlen, and value.

Referenced by array_to_text(), array_to_text_null(), and concat_internal().

array_to_text_null()

Datum array_to_text_null

(

PG_FUNCTION_ARGS

)

Definition at line 3878 of file varlena.c.

{
    ArrayType  *v;
    char       *fldsep;
    char       *null_string;
 
    /* returns NULL when first or second parameter is NULL */
    if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
        PG_RETURN_NULL();
 
    v = PG_GETARG_ARRAYTYPE_P(0);
    fldsep = text_to_cstring(PG_GETARG_TEXT_PP(1));
 
    /* NULL null string is passed through as a null pointer */
    if (!PG_ARGISNULL(2))
        null_string = text_to_cstring(PG_GETARG_TEXT_PP(2));
    else
        null_string = NULL;
 
    PG_RETURN_TEXT_P(array_to_text_internal(fcinfo, v, fldsep, null_string));
}

References array_to_text_internal(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and text_to_cstring().

bpcharfastcmp_c()

static int bpcharfastcmp_c ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 1788 of file varlena.c.

{
    BpChar     *arg1 = DatumGetBpCharPP(x);
    BpChar     *arg2 = DatumGetBpCharPP(y);
    char       *a1p,
               *a2p;
    int         len1,
                len2,
                result;
 
    a1p = VARDATA_ANY(arg1);
    a2p = VARDATA_ANY(arg2);
 
    len1 = bpchartruelen(a1p, VARSIZE_ANY_EXHDR(arg1));
    len2 = bpchartruelen(a2p, VARSIZE_ANY_EXHDR(arg2));
 
    result = memcmp(a1p, a2p, Min(len1, len2));
    if ((result == 0) && (len1 != len2))
        result = (len1 < len2) ? -1 : 1;
 
    /* We can't afford to leak memory here. */
    if (PointerGetDatum(arg1) != x)
        pfree(arg1);
    if (PointerGetDatum(arg2) != y)
        pfree(arg2);
 
    return result;
}

References bpchartruelen(), DatumGetBpCharPP, Min, pfree(), PointerGetDatum(), VARDATA_ANY(), VARSIZE_ANY_EXHDR(), x, and y.

Referenced by varstr_sortsupport().

btnametextcmp()

Datum btnametextcmp

(

PG_FUNCTION_ARGS

)

Definition at line 2427 of file varlena.c.

{
    Name        arg1 = PG_GETARG_NAME(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int32       result;
 
    result = varstr_cmp(NameStr(*arg1), strlen(NameStr(*arg1)),
                        VARDATA_ANY(arg2), VARSIZE_ANY_EXHDR(arg2),
                        PG_GET_COLLATION());
 
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_INT32(result);
}

References NameStr, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_INT32, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

Referenced by namegetext(), namegttext(), nameletext(), and namelttext().

bttext_pattern_cmp()

Datum bttext_pattern_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2610 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int         result;
 
    result = internal_text_pattern_compare(arg1, arg2);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_INT32(result);
}

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, and PG_RETURN_INT32.

bttext_pattern_sortsupport()

Datum bttext_pattern_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 2626 of file varlena.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
    /* Use generic string SortSupport, forcing "C" collation */
    varstr_sortsupport(ssup, TEXTOID, C_COLLATION_OID);
 
    MemoryContextSwitchTo(oldcontext);
 
    PG_RETURN_VOID();
}

References MemoryContextSwitchTo(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, and varstr_sortsupport().

bttextcmp()

Datum bttextcmp

(

PG_FUNCTION_ARGS

)

Definition at line 1573 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int32       result;
 
    result = text_cmp(arg1, arg2, PG_GET_COLLATION());
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_INT32(result);
}

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_INT32, and text_cmp().

Referenced by gbt_text_ssup_cmp(), and gbt_textcmp().

bttextnamecmp()

Datum bttextnamecmp

(

PG_FUNCTION_ARGS

)

Definition at line 2443 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    Name        arg2 = PG_GETARG_NAME(1);
    int32       result;
 
    result = varstr_cmp(VARDATA_ANY(arg1), VARSIZE_ANY_EXHDR(arg1),
                        NameStr(*arg2), strlen(NameStr(*arg2)),
                        PG_GET_COLLATION());
 
    PG_FREE_IF_COPY(arg1, 0);
 
    PG_RETURN_INT32(result);
}

References NameStr, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_INT32, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

Referenced by textgename(), textgtname(), textlename(), and textltname().

bttextsortsupport()

Datum bttextsortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 1588 of file varlena.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
    Oid         collid = ssup->ssup_collation;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
    /* Use generic string SortSupport */
    varstr_sortsupport(ssup, TEXTOID, collid);
 
    MemoryContextSwitchTo(oldcontext);
 
    PG_RETURN_VOID();
}

References collid, MemoryContextSwitchTo(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, and varstr_sortsupport().

btvarstrequalimage()

Datum btvarstrequalimage

(

PG_FUNCTION_ARGS

)

Definition at line 2284 of file varlena.c.

{
    /* Oid      opcintype = PG_GETARG_OID(0); */
    Oid         collid = PG_GET_COLLATION();
    pg_locale_t locale;
 
    check_collation_set(collid);
 
    locale = pg_newlocale_from_collation(collid);
 
    PG_RETURN_BOOL(locale->deterministic);
}

References check_collation_set(), collid, locale, PG_GET_COLLATION, pg_newlocale_from_collation(), and PG_RETURN_BOOL.

build_concat_foutcache()

static FmgrInfo * build_concat_foutcache ( FunctionCallInfo  fcinfo, int  argidx  )

static

Definition at line 4480 of file varlena.c.

{
    FmgrInfo   *foutcache;
    int         i;
 
    /* We keep the info in fn_mcxt so it survives across calls */
    foutcache = (FmgrInfo *) MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                PG_NARGS() * sizeof(FmgrInfo));
 
    for (i = argidx; i < PG_NARGS(); i++)
    {
        Oid         valtype;
        Oid         typOutput;
        bool        typIsVarlena;
 
        valtype = get_fn_expr_argtype(fcinfo->flinfo, i);
        if (!OidIsValid(valtype))
            elog(ERROR, "could not determine data type of concat() input");
 
        getTypeOutputInfo(valtype, &typOutput, &typIsVarlena);
        fmgr_info_cxt(typOutput, &foutcache[i], fcinfo->flinfo->fn_mcxt);
    }
 
    fcinfo->flinfo->fn_extra = foutcache;
 
    return foutcache;
}

References elog, ERROR, FunctionCallInfoBaseData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, get_fn_expr_argtype(), getTypeOutputInfo(), i, MemoryContextAlloc(), OidIsValid, and PG_NARGS.

Referenced by concat_internal().

charlen_to_bytelen()

static int charlen_to_bytelen ( const char *  p, int  n  )

static

Definition at line 501 of file varlena.c.

{
    if (pg_database_encoding_max_length() == 1)
    {
        /* Optimization for single-byte encodings */
        return n;
    }
    else
    {
        const char *s;
 
        for (s = p; n > 0; n--)
            s += pg_mblen(s);
 
        return s - p;
    }
}

References pg_database_encoding_max_length(), and pg_mblen().

Referenced by appendStringInfoRegexpSubstr(), and replace_text_regexp().

check_collation_set()

static void check_collation_set ( Oid  collid )

static

Definition at line 1268 of file varlena.c.

{
    if (!OidIsValid(collid))
    {
        /*
         * This typically means that the parser could not resolve a conflict
         * of implicit collations, so report it that way.
         */
        ereport(ERROR,
                (errcode(ERRCODE_INDETERMINATE_COLLATION),
                 errmsg("could not determine which collation to use for string comparison"),
                 errhint("Use the COLLATE clause to set the collation explicitly.")));
    }
}

References collid, ereport, errcode(), errhint(), errmsg(), ERROR, and OidIsValid.

Referenced by btvarstrequalimage(), nameeqtext(), namenetext(), text_position(), text_position_setup(), text_starts_with(), texteq(), texteqname(), textne(), textnename(), varstr_cmp(), and varstr_sortsupport().

check_replace_text_has_escape()

static int check_replace_text_has_escape ( const text *  replace_text )

static

Definition at line 3169 of file varlena.c.

{
    int         result = 0;
    const char *p = VARDATA_ANY(replace_text);
    const char *p_end = p + VARSIZE_ANY_EXHDR(replace_text);
 
    while (p < p_end)
    {
        /* Find next escape char, if any. */
        p = memchr(p, '\\', p_end - p);
        if (p == NULL)
            break;
        p++;
        /* Note: a backslash at the end doesn't require extra processing. */
        if (p < p_end)
        {
            if (*p >= '1' && *p <= '9')
                return 2;       /* Found a submatch specifier, so done */
            result = 1;         /* Found some other sequence, keep looking */
            p++;
        }
    }
    return result;
}

References replace_text(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by replace_text_regexp().

concat_internal()

static text * concat_internal ( const char *  sepstr, int  argidx, FunctionCallInfo  fcinfo  )

static

Definition at line 4518 of file varlena.c.

{
    text       *result;
    StringInfoData str;
    FmgrInfo   *foutcache;
    bool        first_arg = true;
    int         i;
 
    /*
     * concat(VARIADIC some-array) is essentially equivalent to
     * array_to_text(), ie concat the array elements with the given separator.
     * So we just pass the case off to that code.
     */
    if (get_fn_expr_variadic(fcinfo->flinfo))
    {
        ArrayType  *arr;
 
        /* Should have just the one argument */
        Assert(argidx == PG_NARGS() - 1);
 
        /* concat(VARIADIC NULL) is defined as NULL */
        if (PG_ARGISNULL(argidx))
            return NULL;
 
        /*
         * Non-null argument had better be an array.  We assume that any call
         * context that could let get_fn_expr_variadic return true will have
         * checked that a VARIADIC-labeled parameter actually is an array.  So
         * it should be okay to just Assert that it's an array rather than
         * doing a full-fledged error check.
         */
        Assert(OidIsValid(get_base_element_type(get_fn_expr_argtype(fcinfo->flinfo, argidx))));
 
        /* OK, safe to fetch the array value */
        arr = PG_GETARG_ARRAYTYPE_P(argidx);
 
        /*
         * And serialize the array.  We tell array_to_text to ignore null
         * elements, which matches the behavior of the loop below.
         */
        return array_to_text_internal(fcinfo, arr, sepstr, NULL);
    }
 
    /* Normal case without explicit VARIADIC marker */
    initStringInfo(&str);
 
    /* Get output function info, building it if first time through */
    foutcache = (FmgrInfo *) fcinfo->flinfo->fn_extra;
    if (foutcache == NULL)
        foutcache = build_concat_foutcache(fcinfo, argidx);
 
    for (i = argidx; i < PG_NARGS(); i++)
    {
        if (!PG_ARGISNULL(i))
        {
            Datum       value = PG_GETARG_DATUM(i);
 
            /* add separator if appropriate */
            if (first_arg)
                first_arg = false;
            else
                appendStringInfoString(&str, sepstr);
 
            /* call the appropriate type output function, append the result */
            appendStringInfoString(&str,
                                   OutputFunctionCall(&foutcache[i], value));
        }
    }
 
    result = cstring_to_text_with_len(str.data, str.len);
    pfree(str.data);
 
    return result;
}

References appendStringInfoString(), array_to_text_internal(), Assert(), build_concat_foutcache(), cstring_to_text_with_len(), FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, get_base_element_type(), get_fn_expr_argtype(), get_fn_expr_variadic(), i, if(), initStringInfo(), OidIsValid, OutputFunctionCall(), pfree(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_NARGS, str, and value.

Referenced by text_concat(), and text_concat_ws().

convert_to_base()

static text * convert_to_base ( uint64  value, int  base  )

inlinestatic

Definition at line 4026 of file varlena.c.

{
    const char *digits = "0123456789abcdef";
 
    /* We size the buffer for to_bin's longest possible return value. */
    char        buf[sizeof(uint64) * BITS_PER_BYTE];
    char       *const end = buf + sizeof(buf);
    char       *ptr = end;
 
    Assert(base > 1);
    Assert(base <= 16);
 
    do
    {
        *--ptr = digits[value % base];
        value /= base;
    } while (ptr > buf && value);
 
    return cstring_to_text_with_len(ptr, end - ptr);
}

References Assert(), BITS_PER_BYTE, buf, cstring_to_text_with_len(), digits, and value.

Referenced by to_bin32(), to_bin64(), to_hex32(), to_hex64(), to_oct32(), and to_oct64().

cstring_to_text()

text * cstring_to_text

(

const char *

s

)

Definition at line 181 of file varlena.c.

{
    return cstring_to_text_with_len(s, strlen(s));
}

References cstring_to_text_with_len().

Referenced by array_dims(), ASN1_STRING_to_text(), booltext(), brin_minmax_multi_summary_out(), brin_page_type(), build_test_info_result(), build_test_match_result(), casefold(), cidr_abbrev(), convert_charset(), cstring_to_xmltype(), current_query(), cvt_name_text(), datetime_to_char_body(), dblink_build_sql_delete(), dblink_build_sql_insert(), dblink_build_sql_update(), dblink_cancel_query(), dblink_close(), dblink_connect(), dblink_disconnect(), dblink_error_message(), dblink_exec(), dblink_open(), dmetaphone(), dmetaphone_alt(), exec_assign_c_string(), executeDateTimeMethod(), filter_list_to_array(), format_type(), get_command_tag(), get_command_type(), get_scalar(), get_val_in_hash(), hash_page_type(), icu_unicode_version(), inet_abbrev(), initcap(), injection_points_list(), json_in(), json_typeof(), jsonb_get_element(), jsonb_typeof(), JsonbValueAsText(), lower(), md5_bytea(), md5_text(), metaphone(), name_bpchar(), name_text(), network_host(), network_show(), oidvectortypes(), ParameterAclCreate(), ParameterAclLookup(), pg_collation_actual_version(), pg_collation_for(), pg_column_compression(), pg_crypt(), pg_current_logfile(), pg_database_collation_actual_version(), pg_describe_object(), pg_export_snapshot(), pg_get_statisticsobjdef_expressions(), pg_get_wal_replay_pause_state(), pg_parameter_aclmask(), pg_relation_filepath(), pg_size_pretty(), pg_size_pretty_numeric(), pg_stat_get_backend_activity(), pg_stat_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), pg_stat_get_slru(), pg_stats_ext_mcvlist_items(), pg_tablespace_location(), pg_walfile_name(), pg_xact_status(), pgsql_version(), pgxml_result_to_text(), quote_ident(), quote_ident_cstr(), quote_nullable(), sepgsql_getcon(), sepgsql_mcstrans_in(), sepgsql_mcstrans_out(), set_config_by_name(), show_all_file_settings(), show_config_by_name(), show_config_by_name_missing_ok(), ShowAllGUCConfig(), soundex(), split_part(), ssl_cipher(), ssl_client_dn(), ssl_issuer_dn(), ssl_version(), string_to_text(), test_canonicalize_path(), test_slru_page_read(), test_slru_page_readonly(), text_substring(), textin(), timeofday(), timetz_at_local(), tsquerytree(), unaccent_dict(), unicode_version(), upper(), xml_encode_special_chars(), xml_in(), and xml_recv().

cstring_to_text_with_len()

text * cstring_to_text_with_len	(	const char *	s,
		int	len
	)

Definition at line 193 of file varlena.c.

{
    text       *result = (text *) palloc(len + VARHDRSZ);
 
    SET_VARSIZE(result, len + VARHDRSZ);
    memcpy(VARDATA(result), s, len);
 
    return result;
}

References len, palloc(), SET_VARSIZE(), VARDATA(), and VARHDRSZ.

Referenced by array_to_json(), array_to_json_pretty(), array_to_text_internal(), brin_minmax_multi_summary_out(), build_regexp_match_result(), build_regexp_split_result(), build_test_match_result(), cash_words(), compute_tsvector_stats(), concat_internal(), convert_to_base(), cstring_to_text(), daitch_mokotoff_coding(), datum_to_json(), do_text_output_multiline(), dotrim(), each_object_field_end(), each_worker_jsonb(), elements_array_element_end(), ExecEvalMergeSupportFunc(), ExecEvalXmlExpr(), executeDateTimeMethod(), executeLikeRegex(), find_or_create_child_node(), fsm_page_contents(), get_array_element_end(), get_array_end(), get_object_end(), get_object_field_end(), get_scalar(), gin_extract_tsquery(), gin_extract_tsvector(), hstore_akeys(), hstore_avals(), hstore_each(), hstore_fetchval(), hstore_skeys(), hstore_slice_to_array(), hstore_subscript_fetch(), hstore_svals(), hstore_to_array_internal(), hstore_to_json(), hstore_to_json_loose(), json_build_array_noargs(), json_build_array_worker(), json_build_object_noargs(), json_build_object_worker(), json_object(), json_object_two_arg(), json_recv(), json_strip_nulls(), jsonb_pretty(), JsonbValueAsText(), leftmostvalue_text(), LogicalOutputWrite(), parse_ident(), pg_gen_salt(), pg_gen_salt_rounds(), pg_get_function_sqlbody(), replace_text(), replace_text_regexp(), row_to_json(), row_to_json_pretty(), serialize_deflist(), split_part(), split_text(), ssl_extension_info(), string_agg_finalfn(), stringinfo_to_xmltype(), text_format(), text_left(), text_right(), textrecv(), transform_json_string_values(), tsquerytree(), tsvector_to_array(), tsvector_unnest(), unistr(), varchar(), varchar_input(), xmltext(), xmltotext_with_options(), and xslt_process().

getClosestMatch()

const char * getClosestMatch

(

ClosestMatchState *

state

)

Definition at line 5339 of file varlena.c.

{
    Assert(state);
 
    return state->match;
}

References Assert().

Referenced by dblink_fdw_validator(), file_fdw_validator(), postgres_fdw_validator(), and postgresql_fdw_validator().

hexval()

static unsigned int hexval ( unsigned char  c )

static

Definition at line 5568 of file varlena.c.

{
    if (c >= '0' && c <= '9')
        return c - '0';
    if (c >= 'a' && c <= 'f')
        return c - 'a' + 0xA;
    if (c >= 'A' && c <= 'F')
        return c - 'A' + 0xA;
    elog(ERROR, "invalid hexadecimal digit");
    return 0;                   /* not reached */
}

References elog, and ERROR.

Referenced by hexval_n().

hexval_n()

static unsigned int hexval_n ( const char *  instr, size_t  n  )

static

Definition at line 5584 of file varlena.c.

{
    unsigned int result = 0;
 
    for (size_t i = 0; i < n; i++)
        result += hexval(instr[i]) << (4 * (n - i - 1));
 
    return result;
}

References hexval(), and i.

Referenced by unistr().

icu_unicode_version()

Datum icu_unicode_version

(

PG_FUNCTION_ARGS

)

Definition at line 5398 of file varlena.c.

{
#ifdef USE_ICU
    PG_RETURN_TEXT_P(cstring_to_text(U_UNICODE_VERSION));
#else
    PG_RETURN_NULL();
#endif
}

References cstring_to_text(), PG_RETURN_NULL, and PG_RETURN_TEXT_P.

Referenced by main().

initClosestMatch()

void initClosestMatch	(	ClosestMatchState *	state,
		const char *	source,
		int	max_d
	)

Definition at line 5284 of file varlena.c.

{
    Assert(state);
    Assert(max_d >= 0);
 
    state->source = source;
    state->min_d = -1;
    state->max_d = max_d;
    state->match = NULL;
}

References Assert(), and source.

Referenced by dblink_fdw_validator(), file_fdw_validator(), postgres_fdw_validator(), and postgresql_fdw_validator().

internal_text_pattern_compare()

static int internal_text_pattern_compare ( text *  arg1, text *  arg2  )

static

Definition at line 2524 of file varlena.c.

{
    int         result;
    int         len1,
                len2;
 
    len1 = VARSIZE_ANY_EXHDR(arg1);
    len2 = VARSIZE_ANY_EXHDR(arg2);
 
    result = memcmp(VARDATA_ANY(arg1), VARDATA_ANY(arg2), Min(len1, len2));
    if (result != 0)
        return result;
    else if (len1 < len2)
        return -1;
    else if (len1 > len2)
        return 1;
    else
        return 0;
}

References Min, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by bttext_pattern_cmp(), text_pattern_ge(), text_pattern_gt(), text_pattern_le(), and text_pattern_lt().

isxdigits_n()

static bool isxdigits_n ( const char *  instr, size_t  n  )

static

Definition at line 5558 of file varlena.c.

{
    for (size_t i = 0; i < n; i++)
        if (!isxdigit((unsigned char) instr[i]))
            return false;
 
    return true;
}

References i.

Referenced by unistr().

makeStringAggState()

static StringInfo makeStringAggState ( FunctionCallInfo  fcinfo )

static

Definition at line 4258 of file varlena.c.

{
    StringInfo  state;
    MemoryContext aggcontext;
    MemoryContext oldcontext;
 
    if (!AggCheckCallContext(fcinfo, &aggcontext))
    {
        /* cannot be called directly because of internal-type argument */
        elog(ERROR, "string_agg_transfn called in non-aggregate context");
    }
 
    /*
     * Create state in aggregate context.  It'll stay there across subsequent
     * calls.
     */
    oldcontext = MemoryContextSwitchTo(aggcontext);
    state = makeStringInfo();
    MemoryContextSwitchTo(oldcontext);
 
    return state;
}

References AggCheckCallContext(), elog, ERROR, makeStringInfo(), and MemoryContextSwitchTo().

Referenced by string_agg_combine(), string_agg_deserialize(), and string_agg_transfn().

name_text()

Datum name_text

(

PG_FUNCTION_ARGS

)

Definition at line 2669 of file varlena.c.

{
    Name        s = PG_GETARG_NAME(0);
 
    PG_RETURN_TEXT_P(cstring_to_text(NameStr(*s)));
}

References cstring_to_text(), NameStr, PG_GETARG_NAME, and PG_RETURN_TEXT_P.

Referenced by nameiclike(), and nameicnlike().

nameeqtext()

Datum nameeqtext

(

PG_FUNCTION_ARGS

)

Definition at line 2327 of file varlena.c.

{
    Name        arg1 = PG_GETARG_NAME(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    size_t      len1 = strlen(NameStr(*arg1));
    size_t      len2 = VARSIZE_ANY_EXHDR(arg2);
    Oid         collid = PG_GET_COLLATION();
    bool        result;
 
    check_collation_set(collid);
 
    if (collid == C_COLLATION_OID)
        result = (len1 == len2 &&
                  memcmp(NameStr(*arg1), VARDATA_ANY(arg2), len1) == 0);
    else
        result = (varstr_cmp(NameStr(*arg1), len1,
                             VARDATA_ANY(arg2), len2,
                             collid) == 0);
 
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, NameStr, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

namefastcmp_c()

static int namefastcmp_c ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 1821 of file varlena.c.

{
    Name        arg1 = DatumGetName(x);
    Name        arg2 = DatumGetName(y);
 
    return strncmp(NameStr(*arg1), NameStr(*arg2), NAMEDATALEN);
}

References DatumGetName(), NAMEDATALEN, NameStr, x, and y.

Referenced by varstr_sortsupport().

namefastcmp_locale()

static int namefastcmp_locale ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 1864 of file varlena.c.

{
    Name        arg1 = DatumGetName(x);
    Name        arg2 = DatumGetName(y);
 
    return varstrfastcmp_locale(NameStr(*arg1), strlen(NameStr(*arg1)),
                                NameStr(*arg2), strlen(NameStr(*arg2)),
                                ssup);
}

References DatumGetName(), NameStr, varstrfastcmp_locale(), x, and y.

Referenced by varstr_sortsupport().

namegetext()

Datum namegetext

(

PG_FUNCTION_ARGS

)

Definition at line 2483 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(btnametextcmp) >= 0);
}

References btnametextcmp(), CmpCall, and PG_RETURN_BOOL.

namegttext()

Datum namegttext

(

PG_FUNCTION_ARGS

)

Definition at line 2477 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(btnametextcmp) > 0);
}

References btnametextcmp(), CmpCall, and PG_RETURN_BOOL.

nameletext()

Datum nameletext

(

PG_FUNCTION_ARGS

)

Definition at line 2471 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(btnametextcmp) <= 0);
}

References btnametextcmp(), CmpCall, and PG_RETURN_BOOL.

namelttext()

Datum namelttext

(

PG_FUNCTION_ARGS

)

Definition at line 2465 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(btnametextcmp) < 0);
}

References btnametextcmp(), CmpCall, and PG_RETURN_BOOL.

namenetext()

Datum namenetext

(

PG_FUNCTION_ARGS

)

Definition at line 2377 of file varlena.c.

{
    Name        arg1 = PG_GETARG_NAME(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    size_t      len1 = strlen(NameStr(*arg1));
    size_t      len2 = VARSIZE_ANY_EXHDR(arg2);
    Oid         collid = PG_GET_COLLATION();
    bool        result;
 
    check_collation_set(collid);
 
    if (collid == C_COLLATION_OID)
        result = !(len1 == len2 &&
                   memcmp(NameStr(*arg1), VARDATA_ANY(arg2), len1) == 0);
    else
        result = !(varstr_cmp(NameStr(*arg1), len1,
                              VARDATA_ANY(arg2), len2,
                              collid) == 0);
 
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, NameStr, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

pg_column_compression()

Datum pg_column_compression

(

PG_FUNCTION_ARGS

)

Definition at line 4157 of file varlena.c.

{
    int         typlen;
    char       *result;
    ToastCompressionId cmid;
 
    /* On first call, get the input type's typlen, and save at *fn_extra */
    if (fcinfo->flinfo->fn_extra == NULL)
    {
        /* Lookup the datatype of the supplied argument */
        Oid         argtypeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
 
        typlen = get_typlen(argtypeid);
        if (typlen == 0)        /* should not happen */
            elog(ERROR, "cache lookup failed for type %u", argtypeid);
 
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(int));
        *((int *) fcinfo->flinfo->fn_extra) = typlen;
    }
    else
        typlen = *((int *) fcinfo->flinfo->fn_extra);
 
    if (typlen != -1)
        PG_RETURN_NULL();
 
    /* get the compression method id stored in the compressed varlena */
    cmid = toast_get_compression_id((struct varlena *)
                                    DatumGetPointer(PG_GETARG_DATUM(0)));
    if (cmid == TOAST_INVALID_COMPRESSION_ID)
        PG_RETURN_NULL();
 
    /* convert compression method id to compression method name */
    switch (cmid)
    {
        case TOAST_PGLZ_COMPRESSION_ID:
            result = "pglz";
            break;
        case TOAST_LZ4_COMPRESSION_ID:
            result = "lz4";
            break;
        default:
            elog(ERROR, "invalid compression method id %d", cmid);
    }
 
    PG_RETURN_TEXT_P(cstring_to_text(result));
}

References cstring_to_text(), DatumGetPointer(), elog, ERROR, get_fn_expr_argtype(), get_typlen(), MemoryContextAlloc(), PG_GETARG_DATUM, PG_RETURN_NULL, PG_RETURN_TEXT_P, toast_get_compression_id(), TOAST_INVALID_COMPRESSION_ID, TOAST_LZ4_COMPRESSION_ID, and TOAST_PGLZ_COMPRESSION_ID.

pg_column_size()

Datum pg_column_size

(

PG_FUNCTION_ARGS

)

Definition at line 4110 of file varlena.c.

{
    Datum       value = PG_GETARG_DATUM(0);
    int32       result;
    int         typlen;
 
    /* On first call, get the input type's typlen, and save at *fn_extra */
    if (fcinfo->flinfo->fn_extra == NULL)
    {
        /* Lookup the datatype of the supplied argument */
        Oid         argtypeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
 
        typlen = get_typlen(argtypeid);
        if (typlen == 0)        /* should not happen */
            elog(ERROR, "cache lookup failed for type %u", argtypeid);
 
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(int));
        *((int *) fcinfo->flinfo->fn_extra) = typlen;
    }
    else
        typlen = *((int *) fcinfo->flinfo->fn_extra);
 
    if (typlen == -1)
    {
        /* varlena type, possibly toasted */
        result = toast_datum_size(value);
    }
    else if (typlen == -2)
    {
        /* cstring */
        result = strlen(DatumGetCString(value)) + 1;
    }
    else
    {
        /* ordinary fixed-width type */
        result = typlen;
    }
 
    PG_RETURN_INT32(result);
}

References DatumGetCString(), elog, ERROR, get_fn_expr_argtype(), get_typlen(), MemoryContextAlloc(), PG_GETARG_DATUM, PG_RETURN_INT32, toast_datum_size(), and value.

pg_column_toast_chunk_id()

Datum pg_column_toast_chunk_id

(

PG_FUNCTION_ARGS

)

Definition at line 4210 of file varlena.c.

{
    int         typlen;
    struct varlena *attr;
    struct varatt_external toast_pointer;
 
    /* On first call, get the input type's typlen, and save at *fn_extra */
    if (fcinfo->flinfo->fn_extra == NULL)
    {
        /* Lookup the datatype of the supplied argument */
        Oid         argtypeid = get_fn_expr_argtype(fcinfo->flinfo, 0);
 
        typlen = get_typlen(argtypeid);
        if (typlen == 0)        /* should not happen */
            elog(ERROR, "cache lookup failed for type %u", argtypeid);
 
        fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                      sizeof(int));
        *((int *) fcinfo->flinfo->fn_extra) = typlen;
    }
    else
        typlen = *((int *) fcinfo->flinfo->fn_extra);
 
    if (typlen != -1)
        PG_RETURN_NULL();
 
    attr = (struct varlena *) DatumGetPointer(PG_GETARG_DATUM(0));
 
    if (!VARATT_IS_EXTERNAL_ONDISK(attr))
        PG_RETURN_NULL();
 
    VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr);
 
    PG_RETURN_OID(toast_pointer.va_valueid);
}

References DatumGetPointer(), elog, ERROR, get_fn_expr_argtype(), get_typlen(), MemoryContextAlloc(), PG_GETARG_DATUM, PG_RETURN_NULL, PG_RETURN_OID, varatt_external::va_valueid, VARATT_EXTERNAL_GET_POINTER, and VARATT_IS_EXTERNAL_ONDISK().

replace_text()

Datum replace_text

(

PG_FUNCTION_ARGS

)

Definition at line 3092 of file varlena.c.

{
    text       *src_text = PG_GETARG_TEXT_PP(0);
    text       *from_sub_text = PG_GETARG_TEXT_PP(1);
    text       *to_sub_text = PG_GETARG_TEXT_PP(2);
    int         src_text_len;
    int         from_sub_text_len;
    TextPositionState state;
    text       *ret_text;
    int         chunk_len;
    char       *curr_ptr;
    char       *start_ptr;
    StringInfoData str;
    bool        found;
 
    src_text_len = VARSIZE_ANY_EXHDR(src_text);
    from_sub_text_len = VARSIZE_ANY_EXHDR(from_sub_text);
 
    /* Return unmodified source string if empty source or pattern */
    if (src_text_len < 1 || from_sub_text_len < 1)
    {
        PG_RETURN_TEXT_P(src_text);
    }
 
    text_position_setup(src_text, from_sub_text, PG_GET_COLLATION(), &state);
 
    found = text_position_next(&state);
 
    /* When the from_sub_text is not found, there is nothing to do. */
    if (!found)
    {
        text_position_cleanup(&state);
        PG_RETURN_TEXT_P(src_text);
    }
    curr_ptr = text_position_get_match_ptr(&state);
    start_ptr = VARDATA_ANY(src_text);
 
    initStringInfo(&str);
 
    do
    {
        CHECK_FOR_INTERRUPTS();
 
        /* copy the data skipped over by last text_position_next() */
        chunk_len = curr_ptr - start_ptr;
        appendBinaryStringInfo(&str, start_ptr, chunk_len);
 
        appendStringInfoText(&str, to_sub_text);
 
        start_ptr = curr_ptr + state.last_match_len;
 
        found = text_position_next(&state);
        if (found)
            curr_ptr = text_position_get_match_ptr(&state);
    }
    while (found);
 
    /* copy trailing data */
    chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
    appendBinaryStringInfo(&str, start_ptr, chunk_len);
 
    text_position_cleanup(&state);
 
    ret_text = cstring_to_text_with_len(str.data, str.len);
    pfree(str.data);
 
    PG_RETURN_TEXT_P(ret_text);
}

References appendBinaryStringInfo(), appendStringInfoText(), CHECK_FOR_INTERRUPTS, cstring_to_text_with_len(), initStringInfo(), pfree(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, str, text_position_cleanup(), text_position_get_match_ptr(), text_position_next(), text_position_setup(), VARDATA_ANY(), VARSIZE_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by appendStringInfoRegexpSubstr(), check_replace_text_has_escape(), execute_extension_script(), and replace_text_regexp().

replace_text_regexp()

text * replace_text_regexp	(	text *	src_text,
		text *	pattern_text,
		text *	replace_text,
		int	cflags,
		Oid	collation,
		int	search_start,
		int	n
	)

Definition at line 3302 of file varlena.c.

{
    text       *ret_text;
    regex_t    *re;
    int         src_text_len = VARSIZE_ANY_EXHDR(src_text);
    int         nmatches = 0;
    StringInfoData buf;
    regmatch_t  pmatch[10];     /* main match, plus \1 to \9 */
    int         nmatch = lengthof(pmatch);
    pg_wchar   *data;
    size_t      data_len;
    int         data_pos;
    char       *start_ptr;
    int         escape_status;
 
    initStringInfo(&buf);
 
    /* Convert data string to wide characters. */
    data = (pg_wchar *) palloc((src_text_len + 1) * sizeof(pg_wchar));
    data_len = pg_mb2wchar_with_len(VARDATA_ANY(src_text), data, src_text_len);
 
    /* Check whether replace_text has escapes, especially regexp submatches. */
    escape_status = check_replace_text_has_escape(replace_text);
 
    /* If no regexp submatches, we can use REG_NOSUB. */
    if (escape_status < 2)
    {
        cflags |= REG_NOSUB;
        /* Also tell pg_regexec we only want the whole-match location. */
        nmatch = 1;
    }
 
    /* Prepare the regexp. */
    re = RE_compile_and_cache(pattern_text, cflags, collation);
 
    /* start_ptr points to the data_pos'th character of src_text */
    start_ptr = (char *) VARDATA_ANY(src_text);
    data_pos = 0;
 
    while (search_start <= data_len)
    {
        int         regexec_result;
 
        CHECK_FOR_INTERRUPTS();
 
        regexec_result = pg_regexec(re,
                                    data,
                                    data_len,
                                    search_start,
                                    NULL,   /* no details */
                                    nmatch,
                                    pmatch,
                                    0);
 
        if (regexec_result == REG_NOMATCH)
            break;
 
        if (regexec_result != REG_OKAY)
        {
            char        errMsg[100];
 
            pg_regerror(regexec_result, re, errMsg, sizeof(errMsg));
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                     errmsg("regular expression failed: %s", errMsg)));
        }
 
        /*
         * Count matches, and decide whether to replace this match.
         */
        nmatches++;
        if (n > 0 && nmatches != n)
        {
            /*
             * No, so advance search_start, but not start_ptr/data_pos. (Thus,
             * we treat the matched text as if it weren't matched, and copy it
             * to the output later.)
             */
            search_start = pmatch[0].rm_eo;
            if (pmatch[0].rm_so == pmatch[0].rm_eo)
                search_start++;
            continue;
        }
 
        /*
         * Copy the text to the left of the match position.  Note we are given
         * character not byte indexes.
         */
        if (pmatch[0].rm_so - data_pos > 0)
        {
            int         chunk_len;
 
            chunk_len = charlen_to_bytelen(start_ptr,
                                           pmatch[0].rm_so - data_pos);
            appendBinaryStringInfo(&buf, start_ptr, chunk_len);
 
            /*
             * Advance start_ptr over that text, to avoid multiple rescans of
             * it if the replace_text contains multiple back-references.
             */
            start_ptr += chunk_len;
            data_pos = pmatch[0].rm_so;
        }
 
        /*
         * Copy the replace_text, processing escapes if any are present.
         */
        if (escape_status > 0)
            appendStringInfoRegexpSubstr(&buf, replace_text, pmatch,
                                         start_ptr, data_pos);
        else
            appendStringInfoText(&buf, replace_text);
 
        /* Advance start_ptr and data_pos over the matched text. */
        start_ptr += charlen_to_bytelen(start_ptr,
                                        pmatch[0].rm_eo - data_pos);
        data_pos = pmatch[0].rm_eo;
 
        /*
         * If we only want to replace one occurrence, we're done.
         */
        if (n > 0)
            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.
         */
        search_start = data_pos;
        if (pmatch[0].rm_so == pmatch[0].rm_eo)
            search_start++;
    }
 
    /*
     * Copy the text to the right of the last match.
     */
    if (data_pos < data_len)
    {
        int         chunk_len;
 
        chunk_len = ((char *) src_text + VARSIZE_ANY(src_text)) - start_ptr;
        appendBinaryStringInfo(&buf, start_ptr, chunk_len);
    }
 
    ret_text = cstring_to_text_with_len(buf.data, buf.len);
    pfree(buf.data);
    pfree(data);
 
    return ret_text;
}

References appendBinaryStringInfo(), appendStringInfoRegexpSubstr(), appendStringInfoText(), buf, charlen_to_bytelen(), CHECK_FOR_INTERRUPTS, check_replace_text_has_escape(), cstring_to_text_with_len(), data, ereport, errcode(), errmsg(), ERROR, initStringInfo(), lengthof, palloc(), pfree(), pg_mb2wchar_with_len(), pg_regerror(), pg_regexec(), RE_compile_and_cache(), REG_NOMATCH, REG_NOSUB, REG_OKAY, regex_t, regmatch_t, replace_text(), VARDATA_ANY(), VARSIZE_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by textregexreplace(), textregexreplace_extended(), and textregexreplace_noopt().

rest_of_char_same()

static bool rest_of_char_same ( const char *  s1, const char *  s2, int  len  )

inlinestatic

Definition at line 5248 of file varlena.c.

{
    while (len > 0)
    {
        len--;
        if (s1[len] != s2[len])
            return false;
    }
    return true;
}

References len, s1, and s2.

Referenced by varstr_levenshtein().

split_part()

Datum split_part

(

PG_FUNCTION_ARGS

)

Definition at line 3464 of file varlena.c.

{
    text       *inputstring = PG_GETARG_TEXT_PP(0);
    text       *fldsep = PG_GETARG_TEXT_PP(1);
    int         fldnum = PG_GETARG_INT32(2);
    int         inputstring_len;
    int         fldsep_len;
    TextPositionState state;
    char       *start_ptr;
    char       *end_ptr;
    text       *result_text;
    bool        found;
 
    /* field number is 1 based */
    if (fldnum == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("field position must not be zero")));
 
    inputstring_len = VARSIZE_ANY_EXHDR(inputstring);
    fldsep_len = VARSIZE_ANY_EXHDR(fldsep);
 
    /* return empty string for empty input string */
    if (inputstring_len < 1)
        PG_RETURN_TEXT_P(cstring_to_text(""));
 
    /* handle empty field separator */
    if (fldsep_len < 1)
    {
        /* if first or last field, return input string, else empty string */
        if (fldnum == 1 || fldnum == -1)
            PG_RETURN_TEXT_P(inputstring);
        else
            PG_RETURN_TEXT_P(cstring_to_text(""));
    }
 
    /* find the first field separator */
    text_position_setup(inputstring, fldsep, PG_GET_COLLATION(), &state);
 
    found = text_position_next(&state);
 
    /* special case if fldsep not found at all */
    if (!found)
    {
        text_position_cleanup(&state);
        /* if first or last field, return input string, else empty string */
        if (fldnum == 1 || fldnum == -1)
            PG_RETURN_TEXT_P(inputstring);
        else
            PG_RETURN_TEXT_P(cstring_to_text(""));
    }
 
    /*
     * take care of a negative field number (i.e. count from the right) by
     * converting to a positive field number; we need total number of fields
     */
    if (fldnum < 0)
    {
        /* we found a fldsep, so there are at least two fields */
        int         numfields = 2;
 
        while (text_position_next(&state))
            numfields++;
 
        /* special case of last field does not require an extra pass */
        if (fldnum == -1)
        {
            start_ptr = text_position_get_match_ptr(&state) + state.last_match_len;
            end_ptr = VARDATA_ANY(inputstring) + inputstring_len;
            text_position_cleanup(&state);
            PG_RETURN_TEXT_P(cstring_to_text_with_len(start_ptr,
                                                      end_ptr - start_ptr));
        }
 
        /* else, convert fldnum to positive notation */
        fldnum += numfields + 1;
 
        /* if nonexistent field, return empty string */
        if (fldnum <= 0)
        {
            text_position_cleanup(&state);
            PG_RETURN_TEXT_P(cstring_to_text(""));
        }
 
        /* reset to pointing at first match, but now with positive fldnum */
        text_position_reset(&state);
        found = text_position_next(&state);
        Assert(found);
    }
 
    /* identify bounds of first field */
    start_ptr = VARDATA_ANY(inputstring);
    end_ptr = text_position_get_match_ptr(&state);
 
    while (found && --fldnum > 0)
    {
        /* identify bounds of next field */
        start_ptr = end_ptr + state.last_match_len;
        found = text_position_next(&state);
        if (found)
            end_ptr = text_position_get_match_ptr(&state);
    }
 
    text_position_cleanup(&state);
 
    if (fldnum > 0)
    {
        /* N'th field separator not found */
        /* if last field requested, return it, else empty string */
        if (fldnum == 1)
        {
            int         last_len = start_ptr - VARDATA_ANY(inputstring);
 
            result_text = cstring_to_text_with_len(start_ptr,
                                                   inputstring_len - last_len);
        }
        else
            result_text = cstring_to_text("");
    }
    else
    {
        /* non-last field requested */
        result_text = cstring_to_text_with_len(start_ptr, end_ptr - start_ptr);
    }
 
    PG_RETURN_TEXT_P(result_text);
}

References Assert(), cstring_to_text(), cstring_to_text_with_len(), ereport, errcode(), errmsg(), ERROR, PG_GET_COLLATION, PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, text_position_cleanup(), text_position_get_match_ptr(), text_position_next(), text_position_reset(), text_position_setup(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

split_text()

static bool split_text ( FunctionCallInfo  fcinfo, SplitTextOutputData *  tstate  )

static

Definition at line 3687 of file varlena.c.

{
    text       *inputstring;
    text       *fldsep;
    text       *null_string;
    Oid         collation = PG_GET_COLLATION();
    int         inputstring_len;
    int         fldsep_len;
    char       *start_ptr;
    text       *result_text;
 
    /* when input string is NULL, then result is NULL too */
    if (PG_ARGISNULL(0))
        return false;
 
    inputstring = PG_GETARG_TEXT_PP(0);
 
    /* fldsep can be NULL */
    if (!PG_ARGISNULL(1))
        fldsep = PG_GETARG_TEXT_PP(1);
    else
        fldsep = NULL;
 
    /* null_string can be NULL or omitted */
    if (PG_NARGS() > 2 && !PG_ARGISNULL(2))
        null_string = PG_GETARG_TEXT_PP(2);
    else
        null_string = NULL;
 
    if (fldsep != NULL)
    {
        /*
         * Normal case with non-null fldsep.  Use the text_position machinery
         * to search for occurrences of fldsep.
         */
        TextPositionState state;
 
        inputstring_len = VARSIZE_ANY_EXHDR(inputstring);
        fldsep_len = VARSIZE_ANY_EXHDR(fldsep);
 
        /* return empty set for empty input string */
        if (inputstring_len < 1)
            return true;
 
        /* empty field separator: return input string as a one-element set */
        if (fldsep_len < 1)
        {
            split_text_accum_result(tstate, inputstring,
                                    null_string, collation);
            return true;
        }
 
        text_position_setup(inputstring, fldsep, collation, &state);
 
        start_ptr = VARDATA_ANY(inputstring);
 
        for (;;)
        {
            bool        found;
            char       *end_ptr;
            int         chunk_len;
 
            CHECK_FOR_INTERRUPTS();
 
            found = text_position_next(&state);
            if (!found)
            {
                /* fetch last field */
                chunk_len = ((char *) inputstring + VARSIZE_ANY(inputstring)) - start_ptr;
                end_ptr = NULL; /* not used, but some compilers complain */
            }
            else
            {
                /* fetch non-last field */
                end_ptr = text_position_get_match_ptr(&state);
                chunk_len = end_ptr - start_ptr;
            }
 
            /* build a temp text datum to pass to split_text_accum_result */
            result_text = cstring_to_text_with_len(start_ptr, chunk_len);
 
            /* stash away this field */
            split_text_accum_result(tstate, result_text,
                                    null_string, collation);
 
            pfree(result_text);
 
            if (!found)
                break;
 
            start_ptr = end_ptr + state.last_match_len;
        }
 
        text_position_cleanup(&state);
    }
    else
    {
        /*
         * When fldsep is NULL, each character in the input string becomes a
         * separate element in the result set.  The separator is effectively
         * the space between characters.
         */
        inputstring_len = VARSIZE_ANY_EXHDR(inputstring);
 
        start_ptr = VARDATA_ANY(inputstring);
 
        while (inputstring_len > 0)
        {
            int         chunk_len = pg_mblen(start_ptr);
 
            CHECK_FOR_INTERRUPTS();
 
            /* build a temp text datum to pass to split_text_accum_result */
            result_text = cstring_to_text_with_len(start_ptr, chunk_len);
 
            /* stash away this field */
            split_text_accum_result(tstate, result_text,
                                    null_string, collation);
 
            pfree(result_text);
 
            start_ptr += chunk_len;
            inputstring_len -= chunk_len;
        }
    }
 
    return true;
}

References CHECK_FOR_INTERRUPTS, cstring_to_text_with_len(), pfree(), PG_ARGISNULL, PG_GET_COLLATION, PG_GETARG_TEXT_PP, pg_mblen(), PG_NARGS, split_text_accum_result(), text_position_cleanup(), text_position_get_match_ptr(), text_position_next(), text_position_setup(), VARDATA_ANY(), VARSIZE_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by text_to_array(), and text_to_table().

split_text_accum_result()

static void split_text_accum_result ( SplitTextOutputData *  tstate, text *  field_value, text *  null_string, Oid  collation  )

static

Definition at line 3823 of file varlena.c.

{
    bool        is_null = false;
 
    if (null_string && text_isequal(field_value, null_string, collation))
        is_null = true;
 
    if (tstate->tupstore)
    {
        Datum       values[1];
        bool        nulls[1];
 
        values[0] = PointerGetDatum(field_value);
        nulls[0] = is_null;
 
        tuplestore_putvalues(tstate->tupstore,
                             tstate->tupdesc,
                             values,
                             nulls);
    }
    else
    {
        tstate->astate = accumArrayResult(tstate->astate,
                                          PointerGetDatum(field_value),
                                          is_null,
                                          TEXTOID,
                                          CurrentMemoryContext);
    }
}

References accumArrayResult(), SplitTextOutputData::astate, CurrentMemoryContext, PointerGetDatum(), text_isequal(), SplitTextOutputData::tupdesc, tuplestore_putvalues(), SplitTextOutputData::tupstore, and values.

Referenced by split_text().

SplitDirectoriesString()

bool SplitDirectoriesString	(	char *	rawstring,
		char	separator,
		List **	namelist
	)

Definition at line 2871 of file varlena.c.

{
    char       *nextp = rawstring;
    bool        done = false;
 
    *namelist = NIL;
 
    while (scanner_isspace(*nextp))
        nextp++;                /* skip leading whitespace */
 
    if (*nextp == '\0')
        return true;            /* allow empty string */
 
    /* At the top of the loop, we are at start of a new directory. */
    do
    {
        char       *curname;
        char       *endp;
 
        if (*nextp == '"')
        {
            /* Quoted name --- collapse quote-quote pairs */
            curname = nextp + 1;
            for (;;)
            {
                endp = strchr(nextp + 1, '"');
                if (endp == NULL)
                    return false;   /* mismatched quotes */
                if (endp[1] != '"')
                    break;      /* found end of quoted name */
                /* Collapse adjacent quotes into one quote, and look again */
                memmove(endp, endp + 1, strlen(endp));
                nextp = endp;
            }
            /* endp now points at the terminating quote */
            nextp = endp + 1;
        }
        else
        {
            /* Unquoted name --- extends to separator or end of string */
            curname = endp = nextp;
            while (*nextp && *nextp != separator)
            {
                /* trailing whitespace should not be included in name */
                if (!scanner_isspace(*nextp))
                    endp = nextp + 1;
                nextp++;
            }
            if (curname == endp)
                return false;   /* empty unquoted name not allowed */
        }
 
        while (scanner_isspace(*nextp))
            nextp++;            /* skip trailing whitespace */
 
        if (*nextp == separator)
        {
            nextp++;
            while (scanner_isspace(*nextp))
                nextp++;        /* skip leading whitespace for next */
            /* we expect another name, so done remains false */
        }
        else if (*nextp == '\0')
            done = true;
        else
            return false;       /* invalid syntax */
 
        /* Now safe to overwrite separator with a null */
        *endp = '\0';
 
        /* Truncate path if it's overlength */
        if (strlen(curname) >= MAXPGPATH)
            curname[MAXPGPATH - 1] = '\0';
 
        /*
         * Finished isolating current name --- add it to list
         */
        curname = pstrdup(curname);
        canonicalize_path(curname);
        *namelist = lappend(*namelist, curname);
 
        /* Loop back if we didn't reach end of string */
    } while (!done);
 
    return true;
}

References canonicalize_path(), lappend(), MAXPGPATH, NIL, pstrdup(), and scanner_isspace().

Referenced by check_oauth_validator(), load_libraries(), and PostmasterMain().

SplitGUCList()

bool SplitGUCList	(	char *	rawstring,
		char	separator,
		List **	namelist
	)

Definition at line 2992 of file varlena.c.

{
    char       *nextp = rawstring;
    bool        done = false;
 
    *namelist = NIL;
 
    while (scanner_isspace(*nextp))
        nextp++;                /* skip leading whitespace */
 
    if (*nextp == '\0')
        return true;            /* allow empty string */
 
    /* At the top of the loop, we are at start of a new identifier. */
    do
    {
        char       *curname;
        char       *endp;
 
        if (*nextp == '"')
        {
            /* Quoted name --- collapse quote-quote pairs */
            curname = nextp + 1;
            for (;;)
            {
                endp = strchr(nextp + 1, '"');
                if (endp == NULL)
                    return false;   /* mismatched quotes */
                if (endp[1] != '"')
                    break;      /* found end of quoted name */
                /* Collapse adjacent quotes into one quote, and look again */
                memmove(endp, endp + 1, strlen(endp));
                nextp = endp;
            }
            /* endp now points at the terminating quote */
            nextp = endp + 1;
        }
        else
        {
            /* Unquoted name --- extends to separator or whitespace */
            curname = nextp;
            while (*nextp && *nextp != separator &&
                   !scanner_isspace(*nextp))
                nextp++;
            endp = nextp;
            if (curname == nextp)
                return false;   /* empty unquoted name not allowed */
        }
 
        while (scanner_isspace(*nextp))
            nextp++;            /* skip trailing whitespace */
 
        if (*nextp == separator)
        {
            nextp++;
            while (scanner_isspace(*nextp))
                nextp++;        /* skip leading whitespace for next */
            /* we expect another name, so done remains false */
        }
        else if (*nextp == '\0')
            done = true;
        else
            return false;       /* invalid syntax */
 
        /* Now safe to overwrite separator with a null */
        *endp = '\0';
 
        /*
         * Finished isolating current name --- add it to list
         */
        *namelist = lappend(*namelist, curname);
 
        /* Loop back if we didn't reach end of string */
    } while (!done);
 
    return true;
}

References lappend(), NIL, and scanner_isspace().

Referenced by check_debug_io_direct(), dumpFunc(), parse_hba_auth_opt(), pg_get_functiondef(), and PostmasterMain().

SplitIdentifierString()

bool SplitIdentifierString	(	char *	rawstring,
		char	separator,
		List **	namelist
	)

Definition at line 2744 of file varlena.c.

{
    char       *nextp = rawstring;
    bool        done = false;
 
    *namelist = NIL;
 
    while (scanner_isspace(*nextp))
        nextp++;                /* skip leading whitespace */
 
    if (*nextp == '\0')
        return true;            /* allow empty string */
 
    /* At the top of the loop, we are at start of a new identifier. */
    do
    {
        char       *curname;
        char       *endp;
 
        if (*nextp == '"')
        {
            /* Quoted name --- collapse quote-quote pairs, no downcasing */
            curname = nextp + 1;
            for (;;)
            {
                endp = strchr(nextp + 1, '"');
                if (endp == NULL)
                    return false;   /* mismatched quotes */
                if (endp[1] != '"')
                    break;      /* found end of quoted name */
                /* Collapse adjacent quotes into one quote, and look again */
                memmove(endp, endp + 1, strlen(endp));
                nextp = endp;
            }
            /* endp now points at the terminating quote */
            nextp = endp + 1;
        }
        else
        {
            /* Unquoted name --- extends to separator or whitespace */
            char       *downname;
            int         len;
 
            curname = nextp;
            while (*nextp && *nextp != separator &&
                   !scanner_isspace(*nextp))
                nextp++;
            endp = nextp;
            if (curname == nextp)
                return false;   /* empty unquoted name not allowed */
 
            /*
             * Downcase the identifier, using same code as main lexer does.
             *
             * XXX because we want to overwrite the input in-place, we cannot
             * support a downcasing transformation that increases the string
             * length.  This is not a problem given the current implementation
             * of downcase_truncate_identifier, but we'll probably have to do
             * something about this someday.
             */
            len = endp - curname;
            downname = downcase_truncate_identifier(curname, len, false);
            Assert(strlen(downname) <= len);
            strncpy(curname, downname, len);    /* strncpy is required here */
            pfree(downname);
        }
 
        while (scanner_isspace(*nextp))
            nextp++;            /* skip trailing whitespace */
 
        if (*nextp == separator)
        {
            nextp++;
            while (scanner_isspace(*nextp))
                nextp++;        /* skip leading whitespace for next */
            /* we expect another name, so done remains false */
        }
        else if (*nextp == '\0')
            done = true;
        else
            return false;       /* invalid syntax */
 
        /* Now safe to overwrite separator with a null */
        *endp = '\0';
 
        /* Truncate name if it's overlength */
        truncate_identifier(curname, strlen(curname), false);
 
        /*
         * Finished isolating current name --- add it to list
         */
        *namelist = lappend(*namelist, curname);
 
        /* Loop back if we didn't reach end of string */
    } while (!done);
 
    return true;
}

References Assert(), downcase_truncate_identifier(), lappend(), len, NIL, pfree(), scanner_isspace(), and truncate_identifier().

Referenced by check_createrole_self_grant(), check_datestyle(), check_log_connections(), check_log_destination(), check_restrict_nonsystem_relation_kind(), check_search_path(), check_temp_tablespaces(), check_wal_consistency_checking(), ExtractExtensionList(), parse_extension_control_file(), parse_output_parameters(), parse_publication_options(), plpgsql_extra_checks_check_hook(), PrepareTempTablespaces(), preprocessNamespacePath(), stringToQualifiedNameList(), textToQualifiedNameList(), and validate_sync_standby_slots().

string_agg_combine()

Datum string_agg_combine

(

PG_FUNCTION_ARGS

)

Definition at line 4337 of file varlena.c.

{
    StringInfo  state1;
    StringInfo  state2;
    MemoryContext agg_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state1 = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (StringInfo) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
    {
        /*
         * NULL state2 is easy, just return state1, which we know is already
         * in the agg_context
         */
        if (state1 == NULL)
            PG_RETURN_NULL();
        PG_RETURN_POINTER(state1);
    }
 
    if (state1 == NULL)
    {
        /* We must copy state2's data into the agg_context */
        MemoryContext old_context;
 
        old_context = MemoryContextSwitchTo(agg_context);
        state1 = makeStringAggState(fcinfo);
        appendBinaryStringInfo(state1, state2->data, state2->len);
        state1->cursor = state2->cursor;
        MemoryContextSwitchTo(old_context);
    }
    else if (state2->len > 0)
    {
        /* Combine ... state1->cursor does not change in this case */
        appendBinaryStringInfo(state1, state2->data, state2->len);
    }
 
    PG_RETURN_POINTER(state1);
}

References AggCheckCallContext(), appendBinaryStringInfo(), StringInfoData::cursor, StringInfoData::data, elog, ERROR, StringInfoData::len, makeStringAggState(), MemoryContextSwitchTo(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_POINTER.

string_agg_deserialize()

Datum string_agg_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 4418 of file varlena.c.

{
    bytea      *sstate;
    StringInfo  result;
    StringInfoData buf;
    char       *data;
    int         datalen;
 
    /* cannot be called directly because of internal-type argument */
    Assert(AggCheckCallContext(fcinfo, NULL));
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = makeStringAggState(fcinfo);
 
    /* cursor */
    result->cursor = pq_getmsgint(&buf, 4);
 
    /* data */
    datalen = VARSIZE_ANY_EXHDR(sstate) - 4;
    data = (char *) pq_getmsgbytes(&buf, datalen);
    appendBinaryStringInfo(result, data, datalen);
 
    pq_getmsgend(&buf);
 
    PG_RETURN_POINTER(result);
}

References AggCheckCallContext(), appendBinaryStringInfo(), Assert(), buf, StringInfoData::cursor, data, initReadOnlyStringInfo(), makeStringAggState(), PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, pq_getmsgbytes(), pq_getmsgend(), pq_getmsgint(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

string_agg_finalfn()

Datum string_agg_finalfn

(

PG_FUNCTION_ARGS

)

Definition at line 4454 of file varlena.c.

{
    StringInfo  state;
 
    /* cannot be called directly because of internal-type argument */
    Assert(AggCheckCallContext(fcinfo, NULL));
 
    state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
 
    if (state != NULL)
    {
        /* As per comment in transfn, strip data before the cursor position */
        PG_RETURN_TEXT_P(cstring_to_text_with_len(&state->data[state->cursor],
                                                  state->len - state->cursor));
    }
    else
        PG_RETURN_NULL();
}

References AggCheckCallContext(), Assert(), cstring_to_text_with_len(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_TEXT_P.

string_agg_serialize()

Datum string_agg_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 4387 of file varlena.c.

{
    StringInfo  state;
    StringInfoData buf;
    bytea      *result;
 
    /* cannot be called directly because of internal-type argument */
    Assert(AggCheckCallContext(fcinfo, NULL));
 
    state = (StringInfo) PG_GETARG_POINTER(0);
 
    pq_begintypsend(&buf);
 
    /* cursor */
    pq_sendint(&buf, state->cursor, 4);
 
    /* data */
    pq_sendbytes(&buf, state->data, state->len);
 
    result = pq_endtypsend(&buf);
 
    PG_RETURN_BYTEA_P(result);
}

References AggCheckCallContext(), Assert(), buf, PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), and pq_sendint().

string_agg_transfn()

Datum string_agg_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 4282 of file varlena.c.

{
    StringInfo  state;
 
    state = PG_ARGISNULL(0) ? NULL : (StringInfo) PG_GETARG_POINTER(0);
 
    /* Append the value unless null, preceding it with the delimiter. */
    if (!PG_ARGISNULL(1))
    {
        text       *value = PG_GETARG_TEXT_PP(1);
        bool        isfirst = false;
 
        /*
         * You might think we can just throw away the first delimiter, however
         * we must keep it as we may be a parallel worker doing partial
         * aggregation building a state to send to the main process.  We need
         * to keep the delimiter of every aggregation so that the combine
         * function can properly join up the strings of two separately
         * partially aggregated results.  The first delimiter is only stripped
         * off in the final function.  To know how much to strip off the front
         * of the string, we store the length of the first delimiter in the
         * StringInfo's cursor field, which we don't otherwise need here.
         */
        if (state == NULL)
        {
            state = makeStringAggState(fcinfo);
            isfirst = true;
        }
 
        if (!PG_ARGISNULL(2))
        {
            text       *delim = PG_GETARG_TEXT_PP(2);
 
            appendStringInfoText(state, delim);
            if (isfirst)
                state->cursor = VARSIZE_ANY_EXHDR(delim);
        }
 
        appendStringInfoText(state, value);
    }
 
    /*
     * The transition type for string_agg() is declared to be "internal",
     * which is a pass-by-value type the same size as a pointer.
     */
    if (state)
        PG_RETURN_POINTER(state);
    PG_RETURN_NULL();
}

References appendStringInfoText(), makeStringAggState(), PG_ARGISNULL, PG_GETARG_POINTER, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_POINTER, value, and VARSIZE_ANY_EXHDR().

text_catenate()

static text * text_catenate ( text *  t1, text *  t2  )

static

Definition at line 460 of file varlena.c.

{
    text       *result;
    int         len1,
                len2,
                len;
    char       *ptr;
 
    len1 = VARSIZE_ANY_EXHDR(t1);
    len2 = VARSIZE_ANY_EXHDR(t2);
 
    /* paranoia ... probably should throw error instead? */
    if (len1 < 0)
        len1 = 0;
    if (len2 < 0)
        len2 = 0;
 
    len = len1 + len2 + VARHDRSZ;
    result = (text *) palloc(len);
 
    /* Set size of result string... */
    SET_VARSIZE(result, len);
 
    /* Fill data field of result string... */
    ptr = VARDATA(result);
    if (len1 > 0)
        memcpy(ptr, VARDATA_ANY(t1), len1);
    if (len2 > 0)
        memcpy(ptr + len1, VARDATA_ANY(t2), len2);
 
    return result;
}

References len, palloc(), SET_VARSIZE(), VARDATA(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

Referenced by text_overlay(), and textcat().

text_cmp()

static int text_cmp ( text *  arg1, text *  arg2, Oid  collid  )

static

Definition at line 1345 of file varlena.c.

{
    char       *a1p,
               *a2p;
    int         len1,
                len2;
 
    a1p = VARDATA_ANY(arg1);
    a2p = VARDATA_ANY(arg2);
 
    len1 = VARSIZE_ANY_EXHDR(arg1);
    len2 = VARSIZE_ANY_EXHDR(arg2);
 
    return varstr_cmp(a1p, len1, a2p, len2, collid);
}

References collid, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

Referenced by bttextcmp(), text_ge(), text_gt(), text_larger(), text_le(), text_lt(), text_smaller(), texteq(), and textne().

text_concat()

Datum text_concat

(

PG_FUNCTION_ARGS

)

Definition at line 4598 of file varlena.c.

{
    text       *result;
 
    result = concat_internal("", 0, fcinfo);
    if (result == NULL)
        PG_RETURN_NULL();
    PG_RETURN_TEXT_P(result);
}

References concat_internal(), PG_RETURN_NULL, and PG_RETURN_TEXT_P.

text_concat_ws()

Datum text_concat_ws

(

PG_FUNCTION_ARGS

)

Definition at line 4613 of file varlena.c.

{
    char       *sep;
    text       *result;
 
    /* return NULL when separator is NULL */
    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();
    sep = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    result = concat_internal(sep, 1, fcinfo);
    if (result == NULL)
        PG_RETURN_NULL();
    PG_RETURN_TEXT_P(result);
}

References concat_internal(), PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, and text_to_cstring().

text_format()

Datum text_format

(

PG_FUNCTION_ARGS

)

Definition at line 4734 of file varlena.c.

{
    text       *fmt;
    StringInfoData str;
    const char *cp;
    const char *start_ptr;
    const char *end_ptr;
    text       *result;
    int         arg;
    bool        funcvariadic;
    int         nargs;
    Datum      *elements = NULL;
    bool       *nulls = NULL;
    Oid         element_type = InvalidOid;
    Oid         prev_type = InvalidOid;
    Oid         prev_width_type = InvalidOid;
    FmgrInfo    typoutputfinfo;
    FmgrInfo    typoutputinfo_width;
 
    /* When format string is null, immediately return null */
    if (PG_ARGISNULL(0))
        PG_RETURN_NULL();
 
    /* If argument is marked VARIADIC, expand array into elements */
    if (get_fn_expr_variadic(fcinfo->flinfo))
    {
        ArrayType  *arr;
        int16       elmlen;
        bool        elmbyval;
        char        elmalign;
        int         nitems;
 
        /* Should have just the one argument */
        Assert(PG_NARGS() == 2);
 
        /* If argument is NULL, we treat it as zero-length array */
        if (PG_ARGISNULL(1))
            nitems = 0;
        else
        {
            /*
             * Non-null argument had better be an array.  We assume that any
             * call context that could let get_fn_expr_variadic return true
             * will have checked that a VARIADIC-labeled parameter actually is
             * an array.  So it should be okay to just Assert that it's an
             * array rather than doing a full-fledged error check.
             */
            Assert(OidIsValid(get_base_element_type(get_fn_expr_argtype(fcinfo->flinfo, 1))));
 
            /* OK, safe to fetch the array value */
            arr = PG_GETARG_ARRAYTYPE_P(1);
 
            /* Get info about array element type */
            element_type = ARR_ELEMTYPE(arr);
            get_typlenbyvalalign(element_type,
                                 &elmlen, &elmbyval, &elmalign);
 
            /* Extract all array elements */
            deconstruct_array(arr, element_type, elmlen, elmbyval, elmalign,
                              &elements, &nulls, &nitems);
        }
 
        nargs = nitems + 1;
        funcvariadic = true;
    }
    else
    {
        /* Non-variadic case, we'll process the arguments individually */
        nargs = PG_NARGS();
        funcvariadic = false;
    }
 
    /* Setup for main loop. */
    fmt = PG_GETARG_TEXT_PP(0);
    start_ptr = VARDATA_ANY(fmt);
    end_ptr = start_ptr + VARSIZE_ANY_EXHDR(fmt);
    initStringInfo(&str);
    arg = 1;                    /* next argument position to print */
 
    /* Scan format string, looking for conversion specifiers. */
    for (cp = start_ptr; cp < end_ptr; cp++)
    {
        int         argpos;
        int         widthpos;
        int         flags;
        int         width;
        Datum       value;
        bool        isNull;
        Oid         typid;
 
        /*
         * If it's not the start of a conversion specifier, just copy it to
         * the output buffer.
         */
        if (*cp != '%')
        {
            appendStringInfoCharMacro(&str, *cp);
            continue;
        }
 
        ADVANCE_PARSE_POINTER(cp, end_ptr);
 
        /* Easy case: %% outputs a single % */
        if (*cp == '%')
        {
            appendStringInfoCharMacro(&str, *cp);
            continue;
        }
 
        /* Parse the optional portions of the format specifier */
        cp = text_format_parse_format(cp, end_ptr,
                                      &argpos, &widthpos,
                                      &flags, &width);
 
        /*
         * Next we should see the main conversion specifier.  Whether or not
         * an argument position was present, it's known that at least one
         * character remains in the string at this point.  Experience suggests
         * that it's worth checking that that character is one of the expected
         * ones before we try to fetch arguments, so as to produce the least
         * confusing response to a mis-formatted specifier.
         */
        if (strchr("sIL", *cp) == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("unrecognized format() type specifier \"%.*s\"",
                            pg_mblen(cp), cp),
                     errhint("For a single \"%%\" use \"%%%%\".")));
 
        /* If indirect width was specified, get its value */
        if (widthpos >= 0)
        {
            /* Collect the specified or next argument position */
            if (widthpos > 0)
                arg = widthpos;
            if (arg >= nargs)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("too few arguments for format()")));
 
            /* Get the value and type of the selected argument */
            if (!funcvariadic)
            {
                value = PG_GETARG_DATUM(arg);
                isNull = PG_ARGISNULL(arg);
                typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
            }
            else
            {
                value = elements[arg - 1];
                isNull = nulls[arg - 1];
                typid = element_type;
            }
            if (!OidIsValid(typid))
                elog(ERROR, "could not determine data type of format() input");
 
            arg++;
 
            /* We can treat NULL width the same as zero */
            if (isNull)
                width = 0;
            else if (typid == INT4OID)
                width = DatumGetInt32(value);
            else if (typid == INT2OID)
                width = DatumGetInt16(value);
            else
            {
                /* For less-usual datatypes, convert to text then to int */
                char       *str;
 
                if (typid != prev_width_type)
                {
                    Oid         typoutputfunc;
                    bool        typIsVarlena;
 
                    getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
                    fmgr_info(typoutputfunc, &typoutputinfo_width);
                    prev_width_type = typid;
                }
 
                str = OutputFunctionCall(&typoutputinfo_width, value);
 
                /* pg_strtoint32 will complain about bad data or overflow */
                width = pg_strtoint32(str);
 
                pfree(str);
            }
        }
 
        /* Collect the specified or next argument position */
        if (argpos > 0)
            arg = argpos;
        if (arg >= nargs)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("too few arguments for format()")));
 
        /* Get the value and type of the selected argument */
        if (!funcvariadic)
        {
            value = PG_GETARG_DATUM(arg);
            isNull = PG_ARGISNULL(arg);
            typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
        }
        else
        {
            value = elements[arg - 1];
            isNull = nulls[arg - 1];
            typid = element_type;
        }
        if (!OidIsValid(typid))
            elog(ERROR, "could not determine data type of format() input");
 
        arg++;
 
        /*
         * Get the appropriate typOutput function, reusing previous one if
         * same type as previous argument.  That's particularly useful in the
         * variadic-array case, but often saves work even for ordinary calls.
         */
        if (typid != prev_type)
        {
            Oid         typoutputfunc;
            bool        typIsVarlena;
 
            getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
            fmgr_info(typoutputfunc, &typoutputfinfo);
            prev_type = typid;
        }
 
        /*
         * And now we can format the value.
         */
        switch (*cp)
        {
            case 's':
            case 'I':
            case 'L':
                text_format_string_conversion(&str, *cp, &typoutputfinfo,
                                              value, isNull,
                                              flags, width);
                break;
            default:
                /* should not get here, because of previous check */
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("unrecognized format() type specifier \"%.*s\"",
                                pg_mblen(cp), cp),
                         errhint("For a single \"%%\" use \"%%%%\".")));
                break;
        }
    }
 
    /* Don't need deconstruct_array results anymore. */
    if (elements != NULL)
        pfree(elements);
    if (nulls != NULL)
        pfree(nulls);
 
    /* Generate results. */
    result = cstring_to_text_with_len(str.data, str.len);
    pfree(str.data);
 
    PG_RETURN_TEXT_P(result);
}

References ADVANCE_PARSE_POINTER, appendStringInfoCharMacro, arg, ARR_ELEMTYPE, Assert(), cstring_to_text_with_len(), DatumGetInt16(), DatumGetInt32(), deconstruct_array(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, fmgr_info(), get_base_element_type(), get_fn_expr_argtype(), get_fn_expr_variadic(), get_typlenbyvalalign(), getTypeOutputInfo(), initStringInfo(), InvalidOid, nitems, OidIsValid, OutputFunctionCall(), pfree(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_GETARG_DATUM, PG_GETARG_TEXT_PP, pg_mblen(), PG_NARGS, PG_RETURN_NULL, PG_RETURN_TEXT_P, pg_strtoint32(), str, text_format_parse_format(), text_format_string_conversion(), value, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by text_format_nv().

text_format_append_string()

static void text_format_append_string ( StringInfo  buf, const char *  str, int  flags, int  width  )

static

Definition at line 5186 of file varlena.c.

{
    bool        align_to_left = false;
    int         len;
 
    /* fast path for typical easy case */
    if (width == 0)
    {
        appendStringInfoString(buf, str);
        return;
    }
 
    if (width < 0)
    {
        /* Negative width: implicit '-' flag, then take absolute value */
        align_to_left = true;
        /* -INT_MIN is undefined */
        if (width <= INT_MIN)
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("number is out of range")));
        width = -width;
    }
    else if (flags & TEXT_FORMAT_FLAG_MINUS)
        align_to_left = true;
 
    len = pg_mbstrlen(str);
    if (align_to_left)
    {
        /* left justify */
        appendStringInfoString(buf, str);
        if (len < width)
            appendStringInfoSpaces(buf, width - len);
    }
    else
    {
        /* right justify */
        if (len < width)
            appendStringInfoSpaces(buf, width - len);
        appendStringInfoString(buf, str);
    }
}

References appendStringInfoSpaces(), appendStringInfoString(), buf, ereport, errcode(), errmsg(), ERROR, len, pg_mbstrlen(), str, and TEXT_FORMAT_FLAG_MINUS.

Referenced by text_format_string_conversion().

text_format_nv()

Datum text_format_nv

(

PG_FUNCTION_ARGS

)

Definition at line 5238 of file varlena.c.

{
    return text_format(fcinfo);
}

References text_format().

text_format_parse_digits()

static bool text_format_parse_digits ( const char **  ptr, const char *  end_ptr, int *  value  )

static

Definition at line 5011 of file varlena.c.

{
    bool        found = false;
    const char *cp = *ptr;
    int         val = 0;
 
    while (*cp >= '0' && *cp <= '9')
    {
        int8        digit = (*cp - '0');
 
        if (unlikely(pg_mul_s32_overflow(val, 10, &val)) ||
            unlikely(pg_add_s32_overflow(val, digit, &val)))
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("number is out of range")));
        ADVANCE_PARSE_POINTER(cp, end_ptr);
        found = true;
    }
 
    *ptr = cp;
    *value = val;
 
    return found;
}

References ADVANCE_PARSE_POINTER, ereport, errcode(), errmsg(), ERROR, pg_add_s32_overflow(), pg_mul_s32_overflow(), unlikely, val, and value.

Referenced by text_format_parse_format().

text_format_parse_format()

static const char * text_format_parse_format ( const char *  start_ptr, const char *  end_ptr, int *  argpos, int *  widthpos, int *  flags, int *  width  )

static

Definition at line 5060 of file varlena.c.

{
    const char *cp = start_ptr;
    int         n;
 
    /* set defaults for output parameters */
    *argpos = -1;
    *widthpos = -1;
    *flags = 0;
    *width = 0;
 
    /* try to identify first number */
    if (text_format_parse_digits(&cp, end_ptr, &n))
    {
        if (*cp != '$')
        {
            /* Must be just a width and a type, so we're done */
            *width = n;
            return cp;
        }
        /* The number was argument position */
        *argpos = n;
        /* Explicit 0 for argument index is immediately refused */
        if (n == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("format specifies argument 0, but arguments are numbered from 1")));
        ADVANCE_PARSE_POINTER(cp, end_ptr);
    }
 
    /* Handle flags (only minus is supported now) */
    while (*cp == '-')
    {
        *flags |= TEXT_FORMAT_FLAG_MINUS;
        ADVANCE_PARSE_POINTER(cp, end_ptr);
    }
 
    if (*cp == '*')
    {
        /* Handle indirect width */
        ADVANCE_PARSE_POINTER(cp, end_ptr);
        if (text_format_parse_digits(&cp, end_ptr, &n))
        {
            /* number in this position must be closed by $ */
            if (*cp != '$')
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("width argument position must be ended by \"$\"")));
            /* The number was width argument position */
            *widthpos = n;
            /* Explicit 0 for argument index is immediately refused */
            if (n == 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("format specifies argument 0, but arguments are numbered from 1")));
            ADVANCE_PARSE_POINTER(cp, end_ptr);
        }
        else
            *widthpos = 0;      /* width's argument position is unspecified */
    }
    else
    {
        /* Check for direct width specification */
        if (text_format_parse_digits(&cp, end_ptr, &n))
            *width = n;
    }
 
    /* cp should now be pointing at type character */
    return cp;
}

References ADVANCE_PARSE_POINTER, ereport, errcode(), errmsg(), ERROR, TEXT_FORMAT_FLAG_MINUS, and text_format_parse_digits().

Referenced by text_format().

text_format_string_conversion()

static void text_format_string_conversion ( StringInfo  buf, char  conversion, FmgrInfo *  typOutputInfo, Datum  value, bool  isNull, int  flags, int  width  )

static

Definition at line 5137 of file varlena.c.

{
    char       *str;
 
    /* Handle NULL arguments before trying to stringify the value. */
    if (isNull)
    {
        if (conversion == 's')
            text_format_append_string(buf, "", flags, width);
        else if (conversion == 'L')
            text_format_append_string(buf, "NULL", flags, width);
        else if (conversion == 'I')
            ereport(ERROR,
                    (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                     errmsg("null values cannot be formatted as an SQL identifier")));
        return;
    }
 
    /* Stringify. */
    str = OutputFunctionCall(typOutputInfo, value);
 
    /* Escape. */
    if (conversion == 'I')
    {
        /* quote_identifier may or may not allocate a new string. */
        text_format_append_string(buf, quote_identifier(str), flags, width);
    }
    else if (conversion == 'L')
    {
        char       *qstr = quote_literal_cstr(str);
 
        text_format_append_string(buf, qstr, flags, width);
        /* quote_literal_cstr() always allocates a new string */
        pfree(qstr);
    }
    else
        text_format_append_string(buf, str, flags, width);
 
    /* Cleanup. */
    pfree(str);
}

References buf, ereport, errcode(), errmsg(), ERROR, OutputFunctionCall(), pfree(), quote_identifier(), quote_literal_cstr(), str, text_format_append_string(), and value.

Referenced by text_format().

text_ge()

Datum text_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1519 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    bool        result;
 
    result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) >= 0);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result);
}

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and text_cmp().

Referenced by gbt_textge().

text_gt()

Datum text_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1504 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    bool        result;
 
    result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) > 0);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result);
}

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and text_cmp().

Referenced by gbt_textgt().

text_isequal()

static bool text_isequal ( text *  txt1, text *  txt2, Oid  collid  )

static

Definition at line 3596 of file varlena.c.

{
    return DatumGetBool(DirectFunctionCall2Coll(texteq,
                                                collid,
                                                PointerGetDatum(txt1),
                                                PointerGetDatum(txt2)));
}

References collid, DatumGetBool(), DirectFunctionCall2Coll(), PointerGetDatum(), and texteq().

Referenced by split_text_accum_result().

text_larger()

Datum text_larger

(

PG_FUNCTION_ARGS

)

Definition at line 2298 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    text       *result;
 
    result = ((text_cmp(arg1, arg2, PG_GET_COLLATION()) > 0) ? arg1 : arg2);
 
    PG_RETURN_TEXT_P(result);
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and text_cmp().

text_le()

Datum text_le

(

PG_FUNCTION_ARGS

)

Definition at line 1489 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    bool        result;
 
    result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) <= 0);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result);
}

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and text_cmp().

Referenced by gbt_textle().

text_left()

Datum text_left

(

PG_FUNCTION_ARGS

)

Definition at line 4634 of file varlena.c.

{
    int         n = PG_GETARG_INT32(1);
 
    if (n < 0)
    {
        text       *str = PG_GETARG_TEXT_PP(0);
        const char *p = VARDATA_ANY(str);
        int         len = VARSIZE_ANY_EXHDR(str);
        int         rlen;
 
        n = pg_mbstrlen_with_len(p, len) + n;
        rlen = pg_mbcharcliplen(p, len, n);
        PG_RETURN_TEXT_P(cstring_to_text_with_len(p, rlen));
    }
    else
        PG_RETURN_TEXT_P(text_substring(PG_GETARG_DATUM(0), 1, n, false));
}

References cstring_to_text_with_len(), len, PG_GETARG_DATUM, PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mbcharcliplen(), pg_mbstrlen_with_len(), PG_RETURN_TEXT_P, str, text_substring(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

text_length()

static int32 text_length ( Datum  str )

static

Definition at line 407 of file varlena.c.

{
    /* fastpath when max encoding length is one */
    if (pg_database_encoding_max_length() == 1)
        return (toast_raw_datum_size(str) - VARHDRSZ);
    else
    {
        text       *t = DatumGetTextPP(str);
 
        return (pg_mbstrlen_with_len(VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t)));
    }
}

References DatumGetTextPP, pg_database_encoding_max_length(), pg_mbstrlen_with_len(), str, toast_raw_datum_size(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

Referenced by textlen(), and textoverlay_no_len().

text_lt()

Datum text_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1474 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    bool        result;
 
    result = (text_cmp(arg1, arg2, PG_GET_COLLATION()) < 0);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result);
}

References PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, and text_cmp().

Referenced by gbt_textlt().

text_name()

Datum text_name

(

PG_FUNCTION_ARGS

)

Definition at line 2646 of file varlena.c.

{
    text       *s = PG_GETARG_TEXT_PP(0);
    Name        result;
    int         len;
 
    len = VARSIZE_ANY_EXHDR(s);
 
    /* Truncate oversize input */
    if (len >= NAMEDATALEN)
        len = pg_mbcliplen(VARDATA_ANY(s), len, NAMEDATALEN - 1);
 
    /* We use palloc0 here to ensure result is zero-padded */
    result = (Name) palloc0(NAMEDATALEN);
    memcpy(NameStr(*result), VARDATA_ANY(s), len);
 
    PG_RETURN_NAME(result);
}

References len, NAMEDATALEN, NameStr, palloc0(), PG_GETARG_TEXT_PP, pg_mbcliplen(), PG_RETURN_NAME, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

text_overlay()

static text * text_overlay ( text *  t1, text *  t2, int  sp, int  sl  )

static

Definition at line 811 of file varlena.c.

{
    text       *result;
    text       *s1;
    text       *s2;
    int         sp_pl_sl;
 
    /*
     * Check for possible integer-overflow cases.  For negative sp, throw a
     * "substring length" error because that's what should be expected
     * according to the spec's definition of OVERLAY().
     */
    if (sp <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_SUBSTRING_ERROR),
                 errmsg("negative substring length not allowed")));
    if (pg_add_s32_overflow(sp, sl, &sp_pl_sl))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("integer out of range")));
 
    s1 = text_substring(PointerGetDatum(t1), 1, sp - 1, false);
    s2 = text_substring(PointerGetDatum(t1), sp_pl_sl, -1, true);
    result = text_catenate(s1, t2);
    result = text_catenate(result, s2);
 
    return result;
}

References ereport, errcode(), errmsg(), ERROR, pg_add_s32_overflow(), PointerGetDatum(), s1, s2, text_catenate(), and text_substring().

Referenced by textoverlay(), and textoverlay_no_len().

text_pattern_ge()

Datum text_pattern_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2578 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int         result;
 
    result = internal_text_pattern_compare(arg1, arg2);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result >= 0);
}

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, and PG_RETURN_BOOL.

text_pattern_gt()

Datum text_pattern_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2594 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int         result;
 
    result = internal_text_pattern_compare(arg1, arg2);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result > 0);
}

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, and PG_RETURN_BOOL.

text_pattern_le()

Datum text_pattern_le

(

PG_FUNCTION_ARGS

)

Definition at line 2562 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int         result;
 
    result = internal_text_pattern_compare(arg1, arg2);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result <= 0);
}

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, and PG_RETURN_BOOL.

text_pattern_lt()

Datum text_pattern_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2546 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    int         result;
 
    result = internal_text_pattern_compare(arg1, arg2);
 
    PG_FREE_IF_COPY(arg1, 0);
    PG_FREE_IF_COPY(arg2, 1);
 
    PG_RETURN_BOOL(result < 0);
}

References internal_text_pattern_compare(), PG_FREE_IF_COPY, PG_GETARG_TEXT_PP, and PG_RETURN_BOOL.

text_position()

static int text_position ( text *  t1, text *  t2, Oid  collid  )

static

Definition at line 871 of file varlena.c.

{
    TextPositionState state;
    int         result;
 
    check_collation_set(collid);
 
    /* Empty needle always matches at position 1 */
    if (VARSIZE_ANY_EXHDR(t2) < 1)
        return 1;
 
    /* Otherwise, can't match if haystack is shorter than needle */
    if (VARSIZE_ANY_EXHDR(t1) < VARSIZE_ANY_EXHDR(t2) &&
        pg_newlocale_from_collation(collid)->deterministic)
        return 0;
 
    text_position_setup(t1, t2, collid, &state);
    /* don't need greedy mode here */
    state.greedy = false;
 
    if (!text_position_next(&state))
        result = 0;
    else
        result = text_position_get_match_pos(&state);
    text_position_cleanup(&state);
    return result;
}

References check_collation_set(), collid, pg_newlocale_from_collation(), text_position_cleanup(), text_position_get_match_pos(), text_position_next(), text_position_setup(), and VARSIZE_ANY_EXHDR().

Referenced by textpos().

text_position_cleanup()

static void text_position_cleanup ( TextPositionState *  state )

static

Definition at line 1261 of file varlena.c.

{
    /* no cleanup needed */
}

Referenced by replace_text(), split_part(), split_text(), and text_position().

text_position_get_match_pos()

static int text_position_get_match_pos ( TextPositionState *  state )

static

Definition at line 1237 of file varlena.c.

{
    /* Convert the byte position to char position. */
    state->refpos += pg_mbstrlen_with_len(state->refpoint,
                                          state->last_match - state->refpoint);
    state->refpoint = state->last_match;
    return state->refpos + 1;
}

References pg_mbstrlen_with_len().

Referenced by text_position().

text_position_get_match_ptr()

static char * text_position_get_match_ptr ( TextPositionState *  state )

static

Definition at line 1226 of file varlena.c.

{
    return state->last_match;
}

Referenced by replace_text(), split_part(), and split_text().

text_position_next()

static bool text_position_next ( TextPositionState *  state )

static

Definition at line 1038 of file varlena.c.

{
    int         needle_len = state->len2;
    char       *start_ptr;
    char       *matchptr;
 
    if (needle_len <= 0)
        return false;           /* result for empty pattern */
 
    /* Start from the point right after the previous match. */
    if (state->last_match)
        start_ptr = state->last_match + state->last_match_len;
    else
        start_ptr = state->str1;
 
retry:
    matchptr = text_position_next_internal(start_ptr, state);
 
    if (!matchptr)
        return false;
 
    /*
     * Found a match for the byte sequence.  If this is a multibyte encoding,
     * where one character's byte sequence can appear inside a longer
     * multi-byte character, we need to verify that the match was at a
     * character boundary, not in the middle of a multi-byte character.
     */
    if (state->is_multibyte_char_in_char && state->locale->deterministic)
    {
        /* Walk one character at a time, until we reach the match. */
 
        /* the search should never move backwards. */
        Assert(state->refpoint <= matchptr);
 
        while (state->refpoint < matchptr)
        {
            /* step to next character. */
            state->refpoint += pg_mblen(state->refpoint);
            state->refpos++;
 
            /*
             * If we stepped over the match's start position, then it was a
             * false positive, where the byte sequence appeared in the middle
             * of a multi-byte character.  Skip it, and continue the search at
             * the next character boundary.
             */
            if (state->refpoint > matchptr)
            {
                start_ptr = state->refpoint;
                goto retry;
            }
        }
    }
 
    state->last_match = matchptr;
    state->last_match_len = state->last_match_len_tmp;
    return true;
}

References Assert(), pg_mblen(), and text_position_next_internal().

Referenced by replace_text(), split_part(), split_text(), and text_position().

text_position_next_internal()

static char * text_position_next_internal ( char *  start_ptr, TextPositionState *  state  )

static

Definition at line 1103 of file varlena.c.

{
    int         haystack_len = state->len1;
    int         needle_len = state->len2;
    int         skiptablemask = state->skiptablemask;
    const char *haystack = state->str1;
    const char *needle = state->str2;
    const char *haystack_end = &haystack[haystack_len];
    const char *hptr;
 
    Assert(start_ptr >= haystack && start_ptr <= haystack_end);
 
    state->last_match_len_tmp = needle_len;
 
    if (!state->locale->deterministic)
    {
        /*
         * With a nondeterministic collation, we have to use an unoptimized
         * route.  We walk through the haystack and see if at each position
         * there is a substring of the remaining string that is equal to the
         * needle under the given collation.
         *
         * Note, the found substring could have a different length than the
         * needle, including being empty.  Callers that want to skip over the
         * found string need to read the length of the found substring from
         * last_match_len rather than just using the length of their needle.
         *
         * Most callers will require "greedy" semantics, meaning that we need
         * to find the longest such substring, not the shortest.  For callers
         * that don't need greedy semantics, we can finish on the first match.
         */
        const char *result_hptr = NULL;
 
        hptr = start_ptr;
        while (hptr < haystack_end)
        {
            /*
             * First check the common case that there is a match in the
             * haystack of exactly the length of the needle.
             */
            if (!state->greedy &&
                haystack_end - hptr >= needle_len &&
                pg_strncoll(hptr, needle_len, needle, needle_len, state->locale) == 0)
                return (char *) hptr;
 
            /*
             * Else check if any of the possible substrings starting at hptr
             * are equal to the needle.
             */
            for (const char *test_end = hptr; test_end < haystack_end; test_end += pg_mblen(test_end))
            {
                if (pg_strncoll(hptr, (test_end - hptr), needle, needle_len, state->locale) == 0)
                {
                    state->last_match_len_tmp = (test_end - hptr);
                    result_hptr = hptr;
                    if (!state->greedy)
                        break;
                }
            }
            if (result_hptr)
                break;
 
            hptr += pg_mblen(hptr);
        }
 
        return (char *) result_hptr;
    }
    else if (needle_len == 1)
    {
        /* No point in using B-M-H for a one-character needle */
        char        nchar = *needle;
 
        hptr = start_ptr;
        while (hptr < haystack_end)
        {
            if (*hptr == nchar)
                return (char *) hptr;
            hptr++;
        }
    }
    else
    {
        const char *needle_last = &needle[needle_len - 1];
 
        /* Start at startpos plus the length of the needle */
        hptr = start_ptr + needle_len - 1;
        while (hptr < haystack_end)
        {
            /* Match the needle scanning *backward* */
            const char *nptr;
            const char *p;
 
            nptr = needle_last;
            p = hptr;
            while (*nptr == *p)
            {
                /* Matched it all?  If so, return 1-based position */
                if (nptr == needle)
                    return (char *) p;
                nptr--, p--;
            }
 
            /*
             * No match, so use the haystack char at hptr to decide how far to
             * advance.  If the needle had any occurrence of that character
             * (or more precisely, one sharing the same skiptable entry)
             * before its last character, then we advance far enough to align
             * the last such needle character with that haystack position.
             * Otherwise we can advance by the whole needle length.
             */
            hptr += state->skiptable[(unsigned char) *hptr & skiptablemask];
        }
    }
 
    return 0;                   /* not found */
}

References Assert(), pg_mblen(), and pg_strncoll().

Referenced by text_position_next().

text_position_reset()

static void text_position_reset ( TextPositionState *  state )

static

Definition at line 1253 of file varlena.c.

{
    state->last_match = NULL;
    state->refpoint = state->str1;
    state->refpos = 0;
}

Referenced by split_part().

text_position_setup()

static void text_position_setup ( text *  t1, text *  t2, Oid  collid, TextPositionState *  state  )

static

Definition at line 917 of file varlena.c.

{
    int         len1 = VARSIZE_ANY_EXHDR(t1);
    int         len2 = VARSIZE_ANY_EXHDR(t2);
 
    check_collation_set(collid);
 
    state->locale = pg_newlocale_from_collation(collid);
 
    /*
     * Most callers need greedy mode, but some might want to unset this to
     * optimize.
     */
    state->greedy = true;
 
    Assert(len2 > 0);
 
    /*
     * Even with a multi-byte encoding, we perform the search using the raw
     * byte sequence, ignoring multibyte issues.  For UTF-8, that works fine,
     * because in UTF-8 the byte sequence of one character cannot contain
     * another character.  For other multi-byte encodings, we do the search
     * initially as a simple byte search, ignoring multibyte issues, but
     * verify afterwards that the match we found is at a character boundary,
     * and continue the search if it was a false match.
     */
    if (pg_database_encoding_max_length() == 1)
        state->is_multibyte_char_in_char = false;
    else if (GetDatabaseEncoding() == PG_UTF8)
        state->is_multibyte_char_in_char = false;
    else
        state->is_multibyte_char_in_char = true;
 
    state->str1 = VARDATA_ANY(t1);
    state->str2 = VARDATA_ANY(t2);
    state->len1 = len1;
    state->len2 = len2;
    state->last_match = NULL;
    state->refpoint = state->str1;
    state->refpos = 0;
 
    /*
     * Prepare the skip table for Boyer-Moore-Horspool searching.  In these
     * notes we use the terminology that the "haystack" is the string to be
     * searched (t1) and the "needle" is the pattern being sought (t2).
     *
     * If the needle is empty or bigger than the haystack then there is no
     * point in wasting cycles initializing the table.  We also choose not to
     * use B-M-H for needles of length 1, since the skip table can't possibly
     * save anything in that case.
     *
     * (With nondeterministic collations, the search is already
     * multibyte-aware, so we don't need this.)
     */
    if (len1 >= len2 && len2 > 1 && state->locale->deterministic)
    {
        int         searchlength = len1 - len2;
        int         skiptablemask;
        int         last;
        int         i;
        const char *str2 = state->str2;
 
        /*
         * First we must determine how much of the skip table to use.  The
         * declaration of TextPositionState allows up to 256 elements, but for
         * short search problems we don't really want to have to initialize so
         * many elements --- it would take too long in comparison to the
         * actual search time.  So we choose a useful skip table size based on
         * the haystack length minus the needle length.  The closer the needle
         * length is to the haystack length the less useful skipping becomes.
         *
         * Note: since we use bit-masking to select table elements, the skip
         * table size MUST be a power of 2, and so the mask must be 2^N-1.
         */
        if (searchlength < 16)
            skiptablemask = 3;
        else if (searchlength < 64)
            skiptablemask = 7;
        else if (searchlength < 128)
            skiptablemask = 15;
        else if (searchlength < 512)
            skiptablemask = 31;
        else if (searchlength < 2048)
            skiptablemask = 63;
        else if (searchlength < 4096)
            skiptablemask = 127;
        else
            skiptablemask = 255;
        state->skiptablemask = skiptablemask;
 
        /*
         * Initialize the skip table.  We set all elements to the needle
         * length, since this is the correct skip distance for any character
         * not found in the needle.
         */
        for (i = 0; i <= skiptablemask; i++)
            state->skiptable[i] = len2;
 
        /*
         * Now examine the needle.  For each character except the last one,
         * set the corresponding table element to the appropriate skip
         * distance.  Note that when two characters share the same skip table
         * entry, the one later in the needle must determine the skip
         * distance.
         */
        last = len2 - 1;
 
        for (i = 0; i < last; i++)
            state->skiptable[(unsigned char) str2[i] & skiptablemask] = last - i;
    }
}

References Assert(), check_collation_set(), collid, for(), GetDatabaseEncoding(), i, pg_database_encoding_max_length(), pg_newlocale_from_collation(), PG_UTF8, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by replace_text(), split_part(), split_text(), and text_position().

text_reverse()

Datum text_reverse

(

PG_FUNCTION_ARGS

)

Definition at line 4679 of file varlena.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    const char *p = VARDATA_ANY(str);
    int         len = VARSIZE_ANY_EXHDR(str);
    const char *endp = p + len;
    text       *result;
    char       *dst;
 
    result = palloc(len + VARHDRSZ);
    dst = (char *) VARDATA(result) + len;
    SET_VARSIZE(result, len + VARHDRSZ);
 
    if (pg_database_encoding_max_length() > 1)
    {
        /* multibyte version */
        while (p < endp)
        {
            int         sz;
 
            sz = pg_mblen(p);
            dst -= sz;
            memcpy(dst, p, sz);
            p += sz;
        }
    }
    else
    {
        /* single byte version */
        while (p < endp)
            *(--dst) = *p++;
    }
 
    PG_RETURN_TEXT_P(result);
}

References len, palloc(), pg_database_encoding_max_length(), PG_GETARG_TEXT_PP, pg_mblen(), PG_RETURN_TEXT_P, SET_VARSIZE(), str, VARDATA(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

text_right()

Datum text_right

(

PG_FUNCTION_ARGS

)

Definition at line 4658 of file varlena.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    const char *p = VARDATA_ANY(str);
    int         len = VARSIZE_ANY_EXHDR(str);
    int         n = PG_GETARG_INT32(1);
    int         off;
 
    if (n < 0)
        n = -n;
    else
        n = pg_mbstrlen_with_len(p, len) - n;
    off = pg_mbcharcliplen(p, len, n);
 
    PG_RETURN_TEXT_P(cstring_to_text_with_len(p + off, len - off));
}

References cstring_to_text_with_len(), len, PG_GETARG_INT32, PG_GETARG_TEXT_PP, pg_mbcharcliplen(), pg_mbstrlen_with_len(), PG_RETURN_TEXT_P, str, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

text_smaller()

Datum text_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 2310 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    text       *arg2 = PG_GETARG_TEXT_PP(1);
    text       *result;
 
    result = ((text_cmp(arg1, arg2, PG_GET_COLLATION()) < 0) ? arg1 : arg2);
 
    PG_RETURN_TEXT_P(result);
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and text_cmp().

text_starts_with()

Datum text_starts_with

(

PG_FUNCTION_ARGS

)

Definition at line 1534 of file varlena.c.

{
    Datum       arg1 = PG_GETARG_DATUM(0);
    Datum       arg2 = PG_GETARG_DATUM(1);
    Oid         collid = PG_GET_COLLATION();
    pg_locale_t mylocale;
    bool        result;
    Size        len1,
                len2;
 
    check_collation_set(collid);
 
    mylocale = pg_newlocale_from_collation(collid);
 
    if (!mylocale->deterministic)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("nondeterministic collations are not supported for substring searches")));
 
    len1 = toast_raw_datum_size(arg1);
    len2 = toast_raw_datum_size(arg2);
    if (len2 > len1)
        result = false;
    else
    {
        text       *targ1 = text_substring(arg1, 1, len2, false);
        text       *targ2 = DatumGetTextPP(arg2);
 
        result = (memcmp(VARDATA_ANY(targ1), VARDATA_ANY(targ2),
                         VARSIZE_ANY_EXHDR(targ2)) == 0);
 
        PG_FREE_IF_COPY(targ1, 0);
        PG_FREE_IF_COPY(targ2, 1);
    }
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, DatumGetTextPP, pg_locale_struct::deterministic, ereport, errcode(), errmsg(), ERROR, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_DATUM, pg_newlocale_from_collation(), PG_RETURN_BOOL, text_substring(), toast_raw_datum_size(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by spg_text_leaf_consistent(), and t_starts_with().

text_substr()

Datum text_substr

(

PG_FUNCTION_ARGS

)

Definition at line 547 of file varlena.c.

{
    PG_RETURN_TEXT_P(text_substring(PG_GETARG_DATUM(0),
                                    PG_GETARG_INT32(1),
                                    PG_GETARG_INT32(2),
                                    false));
}

References PG_GETARG_DATUM, PG_GETARG_INT32, PG_RETURN_TEXT_P, and text_substring().

Referenced by build_regexp_match_result(), build_regexp_split_result(), build_test_match_result(), regexp_substr(), and textregexsubstr().

text_substr_no_len()

Datum text_substr_no_len

(

PG_FUNCTION_ARGS

)

Definition at line 561 of file varlena.c.

{
    PG_RETURN_TEXT_P(text_substring(PG_GETARG_DATUM(0),
                                    PG_GETARG_INT32(1),
                                    -1, true));
}

References PG_GETARG_DATUM, PG_GETARG_INT32, PG_RETURN_TEXT_P, and text_substring().

text_substring()

static text * text_substring ( Datum  str, int32  start, int32  length, bool  length_not_specified  )

static

Definition at line 580 of file varlena.c.

{
    int32       eml = pg_database_encoding_max_length();
    int32       S = start;      /* start position */
    int32       S1;             /* adjusted start position */
    int32       L1;             /* adjusted substring length */
    int32       E;              /* end position */
 
    /*
     * SQL99 says S can be zero or negative (which we don't document), but we
     * still must fetch from the start of the string.
     * https://www.postgresql.org/message-id/170905442373.643.11536838320909376197%40wrigleys.postgresql.org
     */
    S1 = Max(S, 1);
 
    /* life is easy if the encoding max length is 1 */
    if (eml == 1)
    {
        if (length_not_specified)   /* special case - get length to end of
                                     * string */
            L1 = -1;
        else if (length < 0)
        {
            /* SQL99 says to throw an error for E < S, i.e., negative length */
            ereport(ERROR,
                    (errcode(ERRCODE_SUBSTRING_ERROR),
                     errmsg("negative substring length not allowed")));
            L1 = -1;            /* silence stupider compilers */
        }
        else if (pg_add_s32_overflow(S, length, &E))
        {
            /*
             * L could be large enough for S + L to overflow, in which case
             * the substring must run to end of string.
             */
            L1 = -1;
        }
        else
        {
            /*
             * A zero or negative value for the end position can happen if the
             * start was negative or one. SQL99 says to return a zero-length
             * string.
             */
            if (E < 1)
                return cstring_to_text("");
 
            L1 = E - S1;
        }
 
        /*
         * If the start position is past the end of the string, SQL99 says to
         * return a zero-length string -- DatumGetTextPSlice() will do that
         * for us.  We need only convert S1 to zero-based starting position.
         */
        return DatumGetTextPSlice(str, S1 - 1, L1);
    }
    else if (eml > 1)
    {
        /*
         * When encoding max length is > 1, we can't get LC without
         * detoasting, so we'll grab a conservatively large slice now and go
         * back later to do the right thing
         */
        int32       slice_start;
        int32       slice_size;
        int32       slice_strlen;
        text       *slice;
        int32       E1;
        int32       i;
        char       *p;
        char       *s;
        text       *ret;
 
        /*
         * We need to start at position zero because there is no way to know
         * in advance which byte offset corresponds to the supplied start
         * position.
         */
        slice_start = 0;
 
        if (length_not_specified)   /* special case - get length to end of
                                     * string */
            slice_size = L1 = -1;
        else if (length < 0)
        {
            /* SQL99 says to throw an error for E < S, i.e., negative length */
            ereport(ERROR,
                    (errcode(ERRCODE_SUBSTRING_ERROR),
                     errmsg("negative substring length not allowed")));
            slice_size = L1 = -1;   /* silence stupider compilers */
        }
        else if (pg_add_s32_overflow(S, length, &E))
        {
            /*
             * L could be large enough for S + L to overflow, in which case
             * the substring must run to end of string.
             */
            slice_size = L1 = -1;
        }
        else
        {
            /*
             * A zero or negative value for the end position can happen if the
             * start was negative or one. SQL99 says to return a zero-length
             * string.
             */
            if (E < 1)
                return cstring_to_text("");
 
            /*
             * if E is past the end of the string, the tuple toaster will
             * truncate the length for us
             */
            L1 = E - S1;
 
            /*
             * Total slice size in bytes can't be any longer than the start
             * position plus substring length times the encoding max length.
             * If that overflows, we can just use -1.
             */
            if (pg_mul_s32_overflow(E, eml, &slice_size))
                slice_size = -1;
        }
 
        /*
         * If we're working with an untoasted source, no need to do an extra
         * copying step.
         */
        if (VARATT_IS_COMPRESSED(DatumGetPointer(str)) ||
            VARATT_IS_EXTERNAL(DatumGetPointer(str)))
            slice = DatumGetTextPSlice(str, slice_start, slice_size);
        else
            slice = (text *) DatumGetPointer(str);
 
        /* see if we got back an empty string */
        if (VARSIZE_ANY_EXHDR(slice) == 0)
        {
            if (slice != (text *) DatumGetPointer(str))
                pfree(slice);
            return cstring_to_text("");
        }
 
        /* Now we can get the actual length of the slice in MB characters */
        slice_strlen = pg_mbstrlen_with_len(VARDATA_ANY(slice),
                                            VARSIZE_ANY_EXHDR(slice));
 
        /*
         * Check that the start position wasn't > slice_strlen. If so, SQL99
         * says to return a zero-length string.
         */
        if (S1 > slice_strlen)
        {
            if (slice != (text *) DatumGetPointer(str))
                pfree(slice);
            return cstring_to_text("");
        }
 
        /*
         * Adjust L1 and E1 now that we know the slice string length. Again
         * remember that S1 is one based, and slice_start is zero based.
         */
        if (L1 > -1)
            E1 = Min(S1 + L1, slice_start + 1 + slice_strlen);
        else
            E1 = slice_start + 1 + slice_strlen;
 
        /*
         * Find the start position in the slice; remember S1 is not zero based
         */
        p = VARDATA_ANY(slice);
        for (i = 0; i < S1 - 1; i++)
            p += pg_mblen(p);
 
        /* hang onto a pointer to our start position */
        s = p;
 
        /*
         * Count the actual bytes used by the substring of the requested
         * length.
         */
        for (i = S1; i < E1; i++)
            p += pg_mblen(p);
 
        ret = (text *) palloc(VARHDRSZ + (p - s));
        SET_VARSIZE(ret, VARHDRSZ + (p - s));
        memcpy(VARDATA(ret), s, (p - s));
 
        if (slice != (text *) DatumGetPointer(str))
            pfree(slice);
 
        return ret;
    }
    else
        elog(ERROR, "invalid backend encoding: encoding max length < 1");
 
    /* not reached: suppress compiler warning */
    return NULL;
}

References cstring_to_text(), DatumGetPointer(), DatumGetTextPSlice, elog, ereport, errcode(), errmsg(), ERROR, i, Max, Min, palloc(), pfree(), pg_add_s32_overflow(), pg_database_encoding_max_length(), pg_mblen(), pg_mbstrlen_with_len(), pg_mul_s32_overflow(), S, SET_VARSIZE(), start, str, VARATT_IS_COMPRESSED(), VARATT_IS_EXTERNAL(), VARDATA(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

Referenced by text_left(), text_overlay(), text_starts_with(), text_substr(), and text_substr_no_len().

text_to_array()

Datum text_to_array

(

PG_FUNCTION_ARGS

)

Definition at line 3610 of file varlena.c.

{
    SplitTextOutputData tstate;
 
    /* For array output, tstate should start as all zeroes */
    memset(&tstate, 0, sizeof(tstate));
 
    if (!split_text(fcinfo, &tstate))
        PG_RETURN_NULL();
 
    if (tstate.astate == NULL)
        PG_RETURN_ARRAYTYPE_P(construct_empty_array(TEXTOID));
 
    PG_RETURN_DATUM(makeArrayResult(tstate.astate,
                                    CurrentMemoryContext));
}

References SplitTextOutputData::astate, construct_empty_array(), CurrentMemoryContext, makeArrayResult(), PG_RETURN_ARRAYTYPE_P, PG_RETURN_DATUM, PG_RETURN_NULL, and split_text().

Referenced by text_to_array_null().

text_to_array_null()

Datum text_to_array_null

(

PG_FUNCTION_ARGS

)

Definition at line 3636 of file varlena.c.

{
    return text_to_array(fcinfo);
}

References text_to_array().

text_to_cstring()

char * text_to_cstring

(

const text *

t

)

Definition at line 214 of file varlena.c.

{
    /* must cast away the const, unfortunately */
    text       *tunpacked = pg_detoast_datum_packed(unconstify(text *, t));
    int         len = VARSIZE_ANY_EXHDR(tunpacked);
    char       *result;
 
    result = (char *) palloc(len + 1);
    memcpy(result, VARDATA_ANY(tunpacked), len);
    result[len] = '\0';
 
    if (tunpacked != t)
        pfree(tunpacked);
 
    return result;
}

References len, palloc(), pfree(), pg_detoast_datum_packed(), unconstify, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by array_to_text(), array_to_text_null(), binary_upgrade_add_sub_rel_state(), binary_upgrade_create_empty_extension(), binary_upgrade_replorigin_advance(), binary_upgrade_set_missing_value(), connectby_text(), connectby_text_serial(), convert_and_check_filename(), convert_any_priv_string(), convert_column_name(), convert_database_name(), convert_foreign_data_wrapper_name(), convert_function_name(), convert_language_name(), convert_schema_name(), convert_server_name(), convert_tablespace_name(), convert_type_name(), crosstab(), crosstab_hash(), cursor_to_xml(), cursor_to_xmlschema(), daitch_mokotoff(), database_to_xml(), database_to_xml_and_xmlschema(), database_to_xmlschema(), datetime_to_char_body(), dblink_cancel_query(), dblink_close(), dblink_connect(), dblink_disconnect(), dblink_error_message(), dblink_exec(), dblink_fetch(), dblink_get_notify(), dblink_is_busy(), dblink_open(), dblink_record_internal(), dblink_send_query(), deserialize_deflist(), difference(), dmetaphone(), dmetaphone_alt(), do_to_timestamp(), errno_from_string(), ExecAlterExtensionStmt(), execute_extension_script(), executeDateTimeMethod(), get_raw_page_fork(), get_raw_page_fork_1_9(), has_param_priv_byname(), has_sequence_privilege_id_name(), has_sequence_privilege_name(), has_sequence_privilege_name_name(), injection_points_attach(), injection_points_cached(), injection_points_detach(), injection_points_load(), injection_points_run(), injection_points_stats_numcalls(), injection_points_wakeup(), json_object_field(), json_object_field_text(), jsonb_set_lax(), JsonItemFromDatum(), ltree_addtext(), ltree_textadd(), NUM_cache(), parse_datetime(), parse_ident(), pg_backup_start(), pg_create_restore_point(), pg_crypt(), pg_current_logfile(), pg_get_expr_worker(), pg_get_logical_snapshot_info(), pg_get_logical_snapshot_meta(), pg_get_serial_sequence(), pg_index_column_has_property(), pg_index_has_property(), pg_indexam_has_property(), pg_input_is_valid_common(), pg_logical_emit_message_bytea(), pg_ls_replslotdir(), pg_notify(), pg_prewarm(), pg_relation_size(), pg_replication_origin_advance(), pg_replication_origin_create(), pg_replication_origin_drop(), pg_replication_origin_oid(), pg_replication_origin_progress(), pg_replication_origin_session_setup(), pg_size_bytes(), pg_split_walfile_name(), pg_stat_get_progress_info(), pg_stat_get_replication_slot(), pg_stat_have_stats(), pg_stat_reset_replication_slot(), pg_stat_reset_shared(), pg_stat_reset_slru(), pgxml_texttoxmlchar(), phraseto_tsquery_byid(), plainto_tsquery_byid(), postgres_fdw_disconnect(), query_to_xml(), query_to_xml_and_xmlschema(), query_to_xmlschema(), quote_ident(), quote_ident_cstr(), range_constructor3(), regress_setenv(), replorigin_by_oid(), schema_to_xml(), schema_to_xml_and_xmlschema(), schema_to_xmlschema(), sepgsql_mcstrans_in(), sepgsql_mcstrans_out(), soundex(), table_to_xml(), table_to_xml_and_xmlschema(), table_to_xmlschema(), test_canonicalize_path(), test_predtest(), test_slru_page_write(), text2ltree(), text_concat_ws(), textToQualifiedNameList(), to_date(), to_regclass(), to_regcollation(), to_regdatabase(), to_regnamespace(), to_regoper(), to_regoperator(), to_regproc(), to_regprocedure(), to_regrole(), to_regtype(), to_regtypemod(), to_tsquery_byid(), ts_stat_sql(), tsquery_rewrite_query(), tuple_data_split(), unicode_is_normalized(), unicode_normalize_func(), verify_heapam(), websearch_to_tsquery_byid(), X509_NAME_field_to_text(), xml_out_internal(), xmlconcat(), xmlpi(), xmlroot(), and xpath_table().

text_to_cstring_buffer()

void text_to_cstring_buffer	(	const text *	src,
		char *	dst,
		size_t	dst_len
	)

Definition at line 245 of file varlena.c.

{
    /* must cast away the const, unfortunately */
    text       *srcunpacked = pg_detoast_datum_packed(unconstify(text *, src));
    size_t      src_len = VARSIZE_ANY_EXHDR(srcunpacked);
 
    if (dst_len > 0)
    {
        dst_len--;
        if (dst_len >= src_len)
            dst_len = src_len;
        else                    /* ensure truncation is encoding-safe */
            dst_len = pg_mbcliplen(VARDATA_ANY(srcunpacked), src_len, dst_len);
        memcpy(dst, VARDATA_ANY(srcunpacked), dst_len);
        dst[dst_len] = '\0';
    }
 
    if (srcunpacked != src)
        pfree(srcunpacked);
}

References pfree(), pg_detoast_datum_packed(), pg_mbcliplen(), unconstify, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by be_lo_export(), lo_import_internal(), lookup_timezone(), parse_sane_timezone(), pg_gen_salt(), pg_gen_salt_rounds(), timestamp_zone(), timestamptz_zone(), and timetz_zone().

text_to_table()

Datum text_to_table

(

PG_FUNCTION_ARGS

)

Definition at line 3647 of file varlena.c.

{
    ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
    SplitTextOutputData tstate;
 
    tstate.astate = NULL;
    InitMaterializedSRF(fcinfo, MAT_SRF_USE_EXPECTED_DESC);
    tstate.tupstore = rsi->setResult;
    tstate.tupdesc = rsi->setDesc;
 
    (void) split_text(fcinfo, &tstate);
 
    return (Datum) 0;
}

References SplitTextOutputData::astate, InitMaterializedSRF(), MAT_SRF_USE_EXPECTED_DESC, ReturnSetInfo::setDesc, ReturnSetInfo::setResult, and split_text().

Referenced by text_to_table_null().

text_to_table_null()

Datum text_to_table_null

(

PG_FUNCTION_ARGS

)

Definition at line 3671 of file varlena.c.

{
    return text_to_table(fcinfo);
}

References text_to_table().

textcat()

Datum textcat

(

PG_FUNCTION_ARGS

)

Definition at line 445 of file varlena.c.

{
    text       *t1 = PG_GETARG_TEXT_PP(0);
    text       *t2 = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_TEXT_P(text_catenate(t1, t2));
}

References PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and text_catenate().

texteq()

Datum texteq

(

PG_FUNCTION_ARGS

)

Definition at line 1370 of file varlena.c.

{
    Oid         collid = PG_GET_COLLATION();
    pg_locale_t mylocale = 0;
    bool        result;
 
    check_collation_set(collid);
 
    mylocale = pg_newlocale_from_collation(collid);
 
    if (mylocale->deterministic)
    {
        Datum       arg1 = PG_GETARG_DATUM(0);
        Datum       arg2 = PG_GETARG_DATUM(1);
        Size        len1,
                    len2;
 
        /*
         * Since we only care about equality or not-equality, we can avoid all
         * the expense of strcoll() here, and just do bitwise comparison.  In
         * fact, we don't even have to do a bitwise comparison if we can show
         * the lengths of the strings are unequal; which might save us from
         * having to detoast one or both values.
         */
        len1 = toast_raw_datum_size(arg1);
        len2 = toast_raw_datum_size(arg2);
        if (len1 != len2)
            result = false;
        else
        {
            text       *targ1 = DatumGetTextPP(arg1);
            text       *targ2 = DatumGetTextPP(arg2);
 
            result = (memcmp(VARDATA_ANY(targ1), VARDATA_ANY(targ2),
                             len1 - VARHDRSZ) == 0);
 
            PG_FREE_IF_COPY(targ1, 0);
            PG_FREE_IF_COPY(targ2, 1);
        }
    }
    else
    {
        text       *arg1 = PG_GETARG_TEXT_PP(0);
        text       *arg2 = PG_GETARG_TEXT_PP(1);
 
        result = (text_cmp(arg1, arg2, collid) == 0);
 
        PG_FREE_IF_COPY(arg1, 0);
        PG_FREE_IF_COPY(arg2, 1);
    }
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, DatumGetTextPP, pg_locale_struct::deterministic, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_DATUM, PG_GETARG_TEXT_PP, pg_newlocale_from_collation(), PG_RETURN_BOOL, text_cmp(), toast_raw_datum_size(), VARDATA_ANY(), and VARHDRSZ.

Referenced by gbt_texteq(), text_isequal(), and texteqfast().

texteqname()

Datum texteqname

(

PG_FUNCTION_ARGS

)

Definition at line 2352 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    Name        arg2 = PG_GETARG_NAME(1);
    size_t      len1 = VARSIZE_ANY_EXHDR(arg1);
    size_t      len2 = strlen(NameStr(*arg2));
    Oid         collid = PG_GET_COLLATION();
    bool        result;
 
    check_collation_set(collid);
 
    if (collid == C_COLLATION_OID)
        result = (len1 == len2 &&
                  memcmp(VARDATA_ANY(arg1), NameStr(*arg2), len1) == 0);
    else
        result = (varstr_cmp(VARDATA_ANY(arg1), len1,
                             NameStr(*arg2), len2,
                             collid) == 0);
 
    PG_FREE_IF_COPY(arg1, 0);
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, NameStr, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

textgename()

Datum textgename

(

PG_FUNCTION_ARGS

)

Definition at line 2507 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(bttextnamecmp) >= 0);
}

References bttextnamecmp(), CmpCall, and PG_RETURN_BOOL.

textgtname()

Datum textgtname

(

PG_FUNCTION_ARGS

)

Definition at line 2501 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(bttextnamecmp) > 0);
}

References bttextnamecmp(), CmpCall, and PG_RETURN_BOOL.

textin()

Datum textin

(

PG_FUNCTION_ARGS

)

Definition at line 275 of file varlena.c.

{
    char       *inputText = PG_GETARG_CSTRING(0);
 
    PG_RETURN_TEXT_P(cstring_to_text(inputText));
}

References cstring_to_text(), PG_GETARG_CSTRING, and PG_RETURN_TEXT_P.

Referenced by ExecEvalJsonExprPath().

textlen()

Datum textlen

(

PG_FUNCTION_ARGS

)

Definition at line 389 of file varlena.c.

{
    Datum       str = PG_GETARG_DATUM(0);
 
    /* try to avoid decompressing argument */
    PG_RETURN_INT32(text_length(str));
}

References PG_GETARG_DATUM, PG_RETURN_INT32, str, and text_length().

textlename()

Datum textlename

(

PG_FUNCTION_ARGS

)

Definition at line 2495 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(bttextnamecmp) <= 0);
}

References bttextnamecmp(), CmpCall, and PG_RETURN_BOOL.

textltname()

Datum textltname

(

PG_FUNCTION_ARGS

)

Definition at line 2489 of file varlena.c.

{
    PG_RETURN_BOOL(CmpCall(bttextnamecmp) < 0);
}

References bttextnamecmp(), CmpCall, and PG_RETURN_BOOL.

textne()

Datum textne

(

PG_FUNCTION_ARGS

)

Definition at line 1425 of file varlena.c.

{
    Oid         collid = PG_GET_COLLATION();
    pg_locale_t mylocale;
    bool        result;
 
    check_collation_set(collid);
 
    mylocale = pg_newlocale_from_collation(collid);
 
    if (mylocale->deterministic)
    {
        Datum       arg1 = PG_GETARG_DATUM(0);
        Datum       arg2 = PG_GETARG_DATUM(1);
        Size        len1,
                    len2;
 
        /* See comment in texteq() */
        len1 = toast_raw_datum_size(arg1);
        len2 = toast_raw_datum_size(arg2);
        if (len1 != len2)
            result = true;
        else
        {
            text       *targ1 = DatumGetTextPP(arg1);
            text       *targ2 = DatumGetTextPP(arg2);
 
            result = (memcmp(VARDATA_ANY(targ1), VARDATA_ANY(targ2),
                             len1 - VARHDRSZ) != 0);
 
            PG_FREE_IF_COPY(targ1, 0);
            PG_FREE_IF_COPY(targ2, 1);
        }
    }
    else
    {
        text       *arg1 = PG_GETARG_TEXT_PP(0);
        text       *arg2 = PG_GETARG_TEXT_PP(1);
 
        result = (text_cmp(arg1, arg2, collid) != 0);
 
        PG_FREE_IF_COPY(arg1, 0);
        PG_FREE_IF_COPY(arg2, 1);
    }
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, DatumGetTextPP, pg_locale_struct::deterministic, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_DATUM, PG_GETARG_TEXT_PP, pg_newlocale_from_collation(), PG_RETURN_BOOL, text_cmp(), toast_raw_datum_size(), VARDATA_ANY(), and VARHDRSZ.

textnename()

Datum textnename

(

PG_FUNCTION_ARGS

)

Definition at line 2402 of file varlena.c.

{
    text       *arg1 = PG_GETARG_TEXT_PP(0);
    Name        arg2 = PG_GETARG_NAME(1);
    size_t      len1 = VARSIZE_ANY_EXHDR(arg1);
    size_t      len2 = strlen(NameStr(*arg2));
    Oid         collid = PG_GET_COLLATION();
    bool        result;
 
    check_collation_set(collid);
 
    if (collid == C_COLLATION_OID)
        result = !(len1 == len2 &&
                   memcmp(VARDATA_ANY(arg1), NameStr(*arg2), len1) == 0);
    else
        result = !(varstr_cmp(VARDATA_ANY(arg1), len1,
                              NameStr(*arg2), len2,
                              collid) == 0);
 
    PG_FREE_IF_COPY(arg1, 0);
 
    PG_RETURN_BOOL(result);
}

References check_collation_set(), collid, NameStr, PG_FREE_IF_COPY, PG_GET_COLLATION, PG_GETARG_NAME, PG_GETARG_TEXT_PP, PG_RETURN_BOOL, VARDATA_ANY(), VARSIZE_ANY_EXHDR(), and varstr_cmp().

textoctetlen()

Datum textoctetlen

(

PG_FUNCTION_ARGS

)

Definition at line 426 of file varlena.c.

{
    Datum       str = PG_GETARG_DATUM(0);
 
    /* We need not detoast the input at all */
    PG_RETURN_INT32(toast_raw_datum_size(str) - VARHDRSZ);
}

References PG_GETARG_DATUM, PG_RETURN_INT32, str, toast_raw_datum_size(), and VARHDRSZ.

textout()

Datum textout

(

PG_FUNCTION_ARGS

)

Definition at line 286 of file varlena.c.

{
    Datum       txt = PG_GETARG_DATUM(0);
 
    PG_RETURN_CSTRING(TextDatumGetCString(txt));
}

References PG_GETARG_DATUM, PG_RETURN_CSTRING, and TextDatumGetCString.

Referenced by pg_node_tree_out(), plsample_func_handler(), and plsample_trigger_handler().

textoverlay()

Datum textoverlay

(

PG_FUNCTION_ARGS

)

Definition at line 788 of file varlena.c.

{
    text       *t1 = PG_GETARG_TEXT_PP(0);
    text       *t2 = PG_GETARG_TEXT_PP(1);
    int         sp = PG_GETARG_INT32(2);    /* substring start position */
    int         sl = PG_GETARG_INT32(3);    /* substring length */
 
    PG_RETURN_TEXT_P(text_overlay(t1, t2, sp, sl));
}

References PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, and text_overlay().

textoverlay_no_len()

Datum textoverlay_no_len

(

PG_FUNCTION_ARGS

)

Definition at line 799 of file varlena.c.

{
    text       *t1 = PG_GETARG_TEXT_PP(0);
    text       *t2 = PG_GETARG_TEXT_PP(1);
    int         sp = PG_GETARG_INT32(2);    /* substring start position */
    int         sl;
 
    sl = text_length(PointerGetDatum(t2));  /* defaults to length(t2) */
    PG_RETURN_TEXT_P(text_overlay(t1, t2, sp, sl));
}

References PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, PointerGetDatum(), text_length(), and text_overlay().

textpos()

Datum textpos

(

PG_FUNCTION_ARGS

)

Definition at line 848 of file varlena.c.

{
    text       *str = PG_GETARG_TEXT_PP(0);
    text       *search_str = PG_GETARG_TEXT_PP(1);
 
    PG_RETURN_INT32((int32) text_position(str, search_str, PG_GET_COLLATION()));
}

References PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_INT32, str, and text_position().

textrecv()

Datum textrecv

(

PG_FUNCTION_ARGS

)

Definition at line 297 of file varlena.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    text       *result;
    char       *str;
    int         nbytes;
 
    str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
 
    result = cstring_to_text_with_len(str, nbytes);
    pfree(str);
    PG_RETURN_TEXT_P(result);
}

References buf, cstring_to_text_with_len(), pfree(), PG_GETARG_POINTER, PG_RETURN_TEXT_P, pq_getmsgtext(), and str.

textsend()

Datum textsend

(

PG_FUNCTION_ARGS

)

Definition at line 315 of file varlena.c.

{
    text       *t = PG_GETARG_TEXT_PP(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendtext(&buf, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_TEXT_PP, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendtext(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by bpcharsend(), pg_node_tree_send(), and varcharsend().

textToQualifiedNameList()

List * textToQualifiedNameList

(

text *

textval

)

Definition at line 2686 of file varlena.c.

{
    char       *rawname;
    List       *result = NIL;
    List       *namelist;
    ListCell   *l;
 
    /* Convert to C string (handles possible detoasting). */
    /* Note we rely on being able to modify rawname below. */
    rawname = text_to_cstring(textval);
 
    if (!SplitIdentifierString(rawname, '.', &namelist))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid name syntax")));
 
    if (namelist == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("invalid name syntax")));
 
    foreach(l, namelist)
    {
        char       *curname = (char *) lfirst(l);
 
        result = lappend(result, makeString(pstrdup(curname)));
    }
 
    pfree(rawname);
    list_free(namelist);
 
    return result;
}

References ereport, errcode(), errmsg(), ERROR, lappend(), lfirst, list_free(), makeString(), NIL, pfree(), pstrdup(), SplitIdentifierString(), and text_to_cstring().

Referenced by bt_metap(), bt_multi_page_stats(), bt_page_items_internal(), bt_page_stats_internal(), convert_table_name(), currtid_byrelname(), get_raw_page_internal(), get_rel_from_relname(), nextval(), pg_get_serial_sequence(), pg_get_viewdef_name(), pg_get_viewdef_name_ext(), pg_relpages(), pg_relpages_v1_5(), pgrowlocks(), pgstatindex(), pgstatindex_v1_5(), pgstattuple(), pgstattuple_v1_5(), row_security_active_name(), text_regclass(), ts_parse_byname(), and ts_token_type_byname().

to_bin32()

Datum to_bin32

(

PG_FUNCTION_ARGS

)

Definition at line 4052 of file varlena.c.

{
    uint64      value = (uint32) PG_GETARG_INT32(0);
 
    PG_RETURN_TEXT_P(convert_to_base(value, 2));
}

References convert_to_base(), PG_GETARG_INT32, PG_RETURN_TEXT_P, and value.

to_bin64()

Datum to_bin64

(

PG_FUNCTION_ARGS

)

Definition at line 4059 of file varlena.c.

{
    uint64      value = (uint64) PG_GETARG_INT64(0);
 
    PG_RETURN_TEXT_P(convert_to_base(value, 2));
}

References convert_to_base(), PG_GETARG_INT64, PG_RETURN_TEXT_P, and value.

to_hex32()

Datum to_hex32

(

PG_FUNCTION_ARGS

)

Definition at line 4090 of file varlena.c.

{
    uint64      value = (uint32) PG_GETARG_INT32(0);
 
    PG_RETURN_TEXT_P(convert_to_base(value, 16));
}

References convert_to_base(), PG_GETARG_INT32, PG_RETURN_TEXT_P, and value.

Referenced by gin_page_opaque_info(), and gist_page_opaque_info().

to_hex64()

Datum to_hex64

(

PG_FUNCTION_ARGS

)

Definition at line 4097 of file varlena.c.

{
    uint64      value = (uint64) PG_GETARG_INT64(0);
 
    PG_RETURN_TEXT_P(convert_to_base(value, 16));
}

References convert_to_base(), PG_GETARG_INT64, PG_RETURN_TEXT_P, and value.

to_oct32()

Datum to_oct32

(

PG_FUNCTION_ARGS

)

Definition at line 4071 of file varlena.c.

{
    uint64      value = (uint32) PG_GETARG_INT32(0);
 
    PG_RETURN_TEXT_P(convert_to_base(value, 8));
}

References convert_to_base(), PG_GETARG_INT32, PG_RETURN_TEXT_P, and value.

to_oct64()

Datum to_oct64

(

PG_FUNCTION_ARGS

)

Definition at line 4078 of file varlena.c.

{
    uint64      value = (uint64) PG_GETARG_INT64(0);
 
    PG_RETURN_TEXT_P(convert_to_base(value, 8));
}

References convert_to_base(), PG_GETARG_INT64, PG_RETURN_TEXT_P, and value.

unicode_assigned()

Datum unicode_assigned

(

PG_FUNCTION_ARGS

)

Definition at line 5412 of file varlena.c.

{
    text       *input = PG_GETARG_TEXT_PP(0);
    unsigned char *p;
    int         size;
 
    if (GetDatabaseEncoding() != PG_UTF8)
        ereport(ERROR,
                (errmsg("Unicode categorization can only be performed if server encoding is UTF8")));
 
    /* convert to pg_wchar */
    size = pg_mbstrlen_with_len(VARDATA_ANY(input), VARSIZE_ANY_EXHDR(input));
    p = (unsigned char *) VARDATA_ANY(input);
    for (int i = 0; i < size; i++)
    {
        pg_wchar    uchar = utf8_to_unicode(p);
        int         category = unicode_category(uchar);
 
        if (category == PG_U_UNASSIGNED)
            PG_RETURN_BOOL(false);
 
        p += pg_utf_mblen(p);
    }
 
    PG_RETURN_BOOL(true);
}

References ereport, errmsg(), ERROR, GetDatabaseEncoding(), i, input, PG_GETARG_TEXT_PP, pg_mbstrlen_with_len(), PG_RETURN_BOOL, PG_U_UNASSIGNED, PG_UTF8, pg_utf_mblen, unicode_category(), utf8_to_unicode(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

unicode_is_normalized()

Datum unicode_is_normalized

(

PG_FUNCTION_ARGS

)

Definition at line 5506 of file varlena.c.

{
    text       *input = PG_GETARG_TEXT_PP(0);
    char       *formstr = text_to_cstring(PG_GETARG_TEXT_PP(1));
    UnicodeNormalizationForm form;
    int         size;
    pg_wchar   *input_chars;
    pg_wchar   *output_chars;
    unsigned char *p;
    int         i;
    UnicodeNormalizationQC quickcheck;
    int         output_size;
    bool        result;
 
    form = unicode_norm_form_from_string(formstr);
 
    /* convert to pg_wchar */
    size = pg_mbstrlen_with_len(VARDATA_ANY(input), VARSIZE_ANY_EXHDR(input));
    input_chars = palloc((size + 1) * sizeof(pg_wchar));
    p = (unsigned char *) VARDATA_ANY(input);
    for (i = 0; i < size; i++)
    {
        input_chars[i] = utf8_to_unicode(p);
        p += pg_utf_mblen(p);
    }
    input_chars[i] = (pg_wchar) '\0';
    Assert((char *) p == VARDATA_ANY(input) + VARSIZE_ANY_EXHDR(input));
 
    /* quick check (see UAX #15) */
    quickcheck = unicode_is_normalized_quickcheck(form, input_chars);
    if (quickcheck == UNICODE_NORM_QC_YES)
        PG_RETURN_BOOL(true);
    else if (quickcheck == UNICODE_NORM_QC_NO)
        PG_RETURN_BOOL(false);
 
    /* normalize and compare with original */
    output_chars = unicode_normalize(form, input_chars);
 
    output_size = 0;
    for (pg_wchar *wp = output_chars; *wp; wp++)
        output_size++;
 
    result = (size == output_size) &&
        (memcmp(input_chars, output_chars, size * sizeof(pg_wchar)) == 0);
 
    PG_RETURN_BOOL(result);
}

References Assert(), i, input, palloc(), PG_GETARG_TEXT_PP, pg_mbstrlen_with_len(), PG_RETURN_BOOL, pg_utf_mblen, text_to_cstring(), unicode_is_normalized_quickcheck(), unicode_norm_form_from_string(), UNICODE_NORM_QC_NO, UNICODE_NORM_QC_YES, unicode_normalize(), utf8_to_unicode(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

unicode_norm_form_from_string()

static UnicodeNormalizationForm unicode_norm_form_from_string ( const char *  formstr )

static

Definition at line 5352 of file varlena.c.

{
    UnicodeNormalizationForm form = -1;
 
    /*
     * Might as well check this while we're here.
     */
    if (GetDatabaseEncoding() != PG_UTF8)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("Unicode normalization can only be performed if server encoding is UTF8")));
 
    if (pg_strcasecmp(formstr, "NFC") == 0)
        form = UNICODE_NFC;
    else if (pg_strcasecmp(formstr, "NFD") == 0)
        form = UNICODE_NFD;
    else if (pg_strcasecmp(formstr, "NFKC") == 0)
        form = UNICODE_NFKC;
    else if (pg_strcasecmp(formstr, "NFKD") == 0)
        form = UNICODE_NFKD;
    else
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid normalization form: %s", formstr)));
 
    return form;
}

References ereport, errcode(), errmsg(), ERROR, GetDatabaseEncoding(), pg_strcasecmp(), PG_UTF8, UNICODE_NFC, UNICODE_NFD, UNICODE_NFKC, and UNICODE_NFKD.

Referenced by unicode_is_normalized(), and unicode_normalize_func().

unicode_normalize_func()

Datum unicode_normalize_func

(

PG_FUNCTION_ARGS

)

Definition at line 5440 of file varlena.c.

{
    text       *input = PG_GETARG_TEXT_PP(0);
    char       *formstr = text_to_cstring(PG_GETARG_TEXT_PP(1));
    UnicodeNormalizationForm form;
    int         size;
    pg_wchar   *input_chars;
    pg_wchar   *output_chars;
    unsigned char *p;
    text       *result;
    int         i;
 
    form = unicode_norm_form_from_string(formstr);
 
    /* convert to pg_wchar */
    size = pg_mbstrlen_with_len(VARDATA_ANY(input), VARSIZE_ANY_EXHDR(input));
    input_chars = palloc((size + 1) * sizeof(pg_wchar));
    p = (unsigned char *) VARDATA_ANY(input);
    for (i = 0; i < size; i++)
    {
        input_chars[i] = utf8_to_unicode(p);
        p += pg_utf_mblen(p);
    }
    input_chars[i] = (pg_wchar) '\0';
    Assert((char *) p == VARDATA_ANY(input) + VARSIZE_ANY_EXHDR(input));
 
    /* action */
    output_chars = unicode_normalize(form, input_chars);
 
    /* convert back to UTF-8 string */
    size = 0;
    for (pg_wchar *wp = output_chars; *wp; wp++)
    {
        unsigned char buf[4];
 
        unicode_to_utf8(*wp, buf);
        size += pg_utf_mblen(buf);
    }
 
    result = palloc(size + VARHDRSZ);
    SET_VARSIZE(result, size + VARHDRSZ);
 
    p = (unsigned char *) VARDATA_ANY(result);
    for (pg_wchar *wp = output_chars; *wp; wp++)
    {
        unicode_to_utf8(*wp, p);
        p += pg_utf_mblen(p);
    }
    Assert((char *) p == (char *) result + size + VARHDRSZ);
 
    PG_RETURN_TEXT_P(result);
}

References Assert(), buf, i, input, palloc(), PG_GETARG_TEXT_PP, pg_mbstrlen_with_len(), PG_RETURN_TEXT_P, pg_utf_mblen, SET_VARSIZE(), text_to_cstring(), unicode_norm_form_from_string(), unicode_normalize(), unicode_to_utf8(), utf8_to_unicode(), VARDATA_ANY(), VARHDRSZ, and VARSIZE_ANY_EXHDR().

unicode_version()

Datum unicode_version

(

PG_FUNCTION_ARGS

)

Definition at line 5389 of file varlena.c.

{
    PG_RETURN_TEXT_P(cstring_to_text(PG_UNICODE_VERSION));
}

References cstring_to_text(), PG_RETURN_TEXT_P, and PG_UNICODE_VERSION.

unistr()

Datum unistr

(

PG_FUNCTION_ARGS

)

Definition at line 5598 of file varlena.c.

{
    text       *input_text = PG_GETARG_TEXT_PP(0);
    char       *instr;
    int         len;
    StringInfoData str;
    text       *result;
    pg_wchar    pair_first = 0;
    char        cbuf[MAX_UNICODE_EQUIVALENT_STRING + 1];
 
    instr = VARDATA_ANY(input_text);
    len = VARSIZE_ANY_EXHDR(input_text);
 
    initStringInfo(&str);
 
    while (len > 0)
    {
        if (instr[0] == '\\')
        {
            if (len >= 2 &&
                instr[1] == '\\')
            {
                if (pair_first)
                    goto invalid_pair;
                appendStringInfoChar(&str, '\\');
                instr += 2;
                len -= 2;
            }
            else if ((len >= 5 && isxdigits_n(instr + 1, 4)) ||
                     (len >= 6 && instr[1] == 'u' && isxdigits_n(instr + 2, 4)))
            {
                pg_wchar    unicode;
                int         offset = instr[1] == 'u' ? 2 : 1;
 
                unicode = hexval_n(instr + offset, 4);
 
                if (!is_valid_unicode_codepoint(unicode))
                    ereport(ERROR,
                            errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                            errmsg("invalid Unicode code point: %04X", unicode));
 
                if (pair_first)
                {
                    if (is_utf16_surrogate_second(unicode))
                    {
                        unicode = surrogate_pair_to_codepoint(pair_first, unicode);
                        pair_first = 0;
                    }
                    else
                        goto invalid_pair;
                }
                else if (is_utf16_surrogate_second(unicode))
                    goto invalid_pair;
 
                if (is_utf16_surrogate_first(unicode))
                    pair_first = unicode;
                else
                {
                    pg_unicode_to_server(unicode, (unsigned char *) cbuf);
                    appendStringInfoString(&str, cbuf);
                }
 
                instr += 4 + offset;
                len -= 4 + offset;
            }
            else if (len >= 8 && instr[1] == '+' && isxdigits_n(instr + 2, 6))
            {
                pg_wchar    unicode;
 
                unicode = hexval_n(instr + 2, 6);
 
                if (!is_valid_unicode_codepoint(unicode))
                    ereport(ERROR,
                            errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                            errmsg("invalid Unicode code point: %04X", unicode));
 
                if (pair_first)
                {
                    if (is_utf16_surrogate_second(unicode))
                    {
                        unicode = surrogate_pair_to_codepoint(pair_first, unicode);
                        pair_first = 0;
                    }
                    else
                        goto invalid_pair;
                }
                else if (is_utf16_surrogate_second(unicode))
                    goto invalid_pair;
 
                if (is_utf16_surrogate_first(unicode))
                    pair_first = unicode;
                else
                {
                    pg_unicode_to_server(unicode, (unsigned char *) cbuf);
                    appendStringInfoString(&str, cbuf);
                }
 
                instr += 8;
                len -= 8;
            }
            else if (len >= 10 && instr[1] == 'U' && isxdigits_n(instr + 2, 8))
            {
                pg_wchar    unicode;
 
                unicode = hexval_n(instr + 2, 8);
 
                if (!is_valid_unicode_codepoint(unicode))
                    ereport(ERROR,
                            errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                            errmsg("invalid Unicode code point: %04X", unicode));
 
                if (pair_first)
                {
                    if (is_utf16_surrogate_second(unicode))
                    {
                        unicode = surrogate_pair_to_codepoint(pair_first, unicode);
                        pair_first = 0;
                    }
                    else
                        goto invalid_pair;
                }
                else if (is_utf16_surrogate_second(unicode))
                    goto invalid_pair;
 
                if (is_utf16_surrogate_first(unicode))
                    pair_first = unicode;
                else
                {
                    pg_unicode_to_server(unicode, (unsigned char *) cbuf);
                    appendStringInfoString(&str, cbuf);
                }
 
                instr += 10;
                len -= 10;
            }
            else
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("invalid Unicode escape"),
                         errhint("Unicode escapes must be \\XXXX, \\+XXXXXX, \\uXXXX, or \\UXXXXXXXX.")));
        }
        else
        {
            if (pair_first)
                goto invalid_pair;
 
            appendStringInfoChar(&str, *instr++);
            len--;
        }
    }
 
    /* unfinished surrogate pair? */
    if (pair_first)
        goto invalid_pair;
 
    result = cstring_to_text_with_len(str.data, str.len);
    pfree(str.data);
 
    PG_RETURN_TEXT_P(result);
 
invalid_pair:
    ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("invalid Unicode surrogate pair")));
    PG_RETURN_NULL();           /* keep compiler quiet */
}

References appendStringInfoChar(), appendStringInfoString(), cstring_to_text_with_len(), ereport, errcode(), errhint(), errmsg(), ERROR, hexval_n(), initStringInfo(), is_utf16_surrogate_first(), is_utf16_surrogate_second(), is_valid_unicode_codepoint(), isxdigits_n(), len, MAX_UNICODE_EQUIVALENT_STRING, pfree(), PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, pg_unicode_to_server(), str, surrogate_pair_to_codepoint(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

unknownin()

Datum unknownin

(

PG_FUNCTION_ARGS

)

Definition at line 330 of file varlena.c.

{
    char       *str = PG_GETARG_CSTRING(0);
 
    /* representation is same as cstring */
    PG_RETURN_CSTRING(pstrdup(str));
}

References PG_GETARG_CSTRING, PG_RETURN_CSTRING, pstrdup(), and str.

unknownout()

Datum unknownout

(

PG_FUNCTION_ARGS

)

Definition at line 342 of file varlena.c.

{
    /* representation is same as cstring */
    char       *str = PG_GETARG_CSTRING(0);
 
    PG_RETURN_CSTRING(pstrdup(str));
}

References PG_GETARG_CSTRING, PG_RETURN_CSTRING, pstrdup(), and str.

unknownrecv()

Datum unknownrecv

(

PG_FUNCTION_ARGS

)

Definition at line 354 of file varlena.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    char       *str;
    int         nbytes;
 
    str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
    /* representation is same as cstring */
    PG_RETURN_CSTRING(str);
}

References buf, PG_GETARG_POINTER, PG_RETURN_CSTRING, pq_getmsgtext(), and str.

unknownsend()

Datum unknownsend

(

PG_FUNCTION_ARGS

)

Definition at line 369 of file varlena.c.

{
    /* representation is same as cstring */
    char       *str = PG_GETARG_CSTRING(0);
    StringInfoData buf;
 
    pq_begintypsend(&buf);
    pq_sendtext(&buf, str, strlen(str));
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, PG_GETARG_CSTRING, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendtext(), and str.

updateClosestMatch()

void updateClosestMatch	(	ClosestMatchState *	state,
		const char *	candidate
	)

Definition at line 5304 of file varlena.c.

{
    int         dist;
 
    Assert(state);
 
    if (state->source == NULL || state->source[0] == '\0' ||
        candidate == NULL || candidate[0] == '\0')
        return;
 
    /*
     * To avoid ERROR-ing, we check the lengths here instead of setting
     * 'trusted' to false in the call to varstr_levenshtein_less_equal().
     */
    if (strlen(state->source) > MAX_LEVENSHTEIN_STRLEN ||
        strlen(candidate) > MAX_LEVENSHTEIN_STRLEN)
        return;
 
    dist = varstr_levenshtein_less_equal(state->source, strlen(state->source),
                                         candidate, strlen(candidate), 1, 1, 1,
                                         state->max_d, true);
    if (dist <= state->max_d &&
        dist <= strlen(state->source) / 2 &&
        (state->min_d == -1 || dist < state->min_d))
    {
        state->min_d = dist;
        state->match = candidate;
    }
}

References Assert(), MAX_LEVENSHTEIN_STRLEN, and varstr_levenshtein_less_equal().

Referenced by dblink_fdw_validator(), file_fdw_validator(), postgres_fdw_validator(), and postgresql_fdw_validator().

varlenafastcmp_locale()

static int varlenafastcmp_locale ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 1833 of file varlena.c.

{
    VarString  *arg1 = DatumGetVarStringPP(x);
    VarString  *arg2 = DatumGetVarStringPP(y);
    char       *a1p,
               *a2p;
    int         len1,
                len2,
                result;
 
    a1p = VARDATA_ANY(arg1);
    a2p = VARDATA_ANY(arg2);
 
    len1 = VARSIZE_ANY_EXHDR(arg1);
    len2 = VARSIZE_ANY_EXHDR(arg2);
 
    result = varstrfastcmp_locale(a1p, len1, a2p, len2, ssup);
 
    /* We can't afford to leak memory here. */
    if (PointerGetDatum(arg1) != x)
        pfree(arg1);
    if (PointerGetDatum(arg2) != y)
        pfree(arg2);
 
    return result;
}

References DatumGetVarStringPP, pfree(), PointerGetDatum(), VARDATA_ANY(), VARSIZE_ANY_EXHDR(), varstrfastcmp_locale(), x, and y.

Referenced by varstr_sortsupport().

varstr_abbrev_abort()

static bool varstr_abbrev_abort ( int  memtupcount, SortSupport  ssup  )

static

Definition at line 2170 of file varlena.c.

{
    VarStringSortSupport *sss = (VarStringSortSupport *) ssup->ssup_extra;
    double      abbrev_distinct,
                key_distinct;
 
    Assert(ssup->abbreviate);
 
    /* Have a little patience */
    if (memtupcount < 100)
        return false;
 
    abbrev_distinct = estimateHyperLogLog(&sss->abbr_card);
    key_distinct = estimateHyperLogLog(&sss->full_card);
 
    /*
     * Clamp cardinality estimates to at least one distinct value.  While
     * NULLs are generally disregarded, if only NULL values were seen so far,
     * that might misrepresent costs if we failed to clamp.
     */
    if (abbrev_distinct <= 1.0)
        abbrev_distinct = 1.0;
 
    if (key_distinct <= 1.0)
        key_distinct = 1.0;
 
    /*
     * In the worst case all abbreviated keys are identical, while at the same
     * time there are differences within full key strings not captured in
     * abbreviations.
     */
    if (trace_sort)
    {
        double      norm_abbrev_card = abbrev_distinct / (double) memtupcount;
 
        elog(LOG, "varstr_abbrev: abbrev_distinct after %d: %f "
             "(key_distinct: %f, norm_abbrev_card: %f, prop_card: %f)",
             memtupcount, abbrev_distinct, key_distinct, norm_abbrev_card,
             sss->prop_card);
    }
 
    /*
     * If the number of distinct abbreviated keys approximately matches the
     * number of distinct authoritative original keys, that's reason enough to
     * proceed.  We can win even with a very low cardinality set if most
     * tie-breakers only memcmp().  This is by far the most important
     * consideration.
     *
     * While comparisons that are resolved at the abbreviated key level are
     * considerably cheaper than tie-breakers resolved with memcmp(), both of
     * those two outcomes are so much cheaper than a full strcoll() once
     * sorting is underway that it doesn't seem worth it to weigh abbreviated
     * cardinality against the overall size of the set in order to more
     * accurately model costs.  Assume that an abbreviated comparison, and an
     * abbreviated comparison with a cheap memcmp()-based authoritative
     * resolution are equivalent.
     */
    if (abbrev_distinct > key_distinct * sss->prop_card)
    {
        /*
         * When we have exceeded 10,000 tuples, decay required cardinality
         * aggressively for next call.
         *
         * This is useful because the number of comparisons required on
         * average increases at a linearithmic rate, and at roughly 10,000
         * tuples that factor will start to dominate over the linear costs of
         * string transformation (this is a conservative estimate).  The decay
         * rate is chosen to be a little less aggressive than halving -- which
         * (since we're called at points at which memtupcount has doubled)
         * would never see the cost model actually abort past the first call
         * following a decay.  This decay rate is mostly a precaution against
         * a sudden, violent swing in how well abbreviated cardinality tracks
         * full key cardinality.  The decay also serves to prevent a marginal
         * case from being aborted too late, when too much has already been
         * invested in string transformation.
         *
         * It's possible for sets of several million distinct strings with
         * mere tens of thousands of distinct abbreviated keys to still
         * benefit very significantly.  This will generally occur provided
         * each abbreviated key is a proxy for a roughly uniform number of the
         * set's full keys. If it isn't so, we hope to catch that early and
         * abort.  If it isn't caught early, by the time the problem is
         * apparent it's probably not worth aborting.
         */
        if (memtupcount > 10000)
            sss->prop_card *= 0.65;
 
        return false;
    }
 
    /*
     * Abort abbreviation strategy.
     *
     * The worst case, where all abbreviated keys are identical while all
     * original strings differ will typically only see a regression of about
     * 10% in execution time for small to medium sized lists of strings.
     * Whereas on modern CPUs where cache stalls are the dominant cost, we can
     * often expect very large improvements, particularly with sets of strings
     * of moderately high to high abbreviated cardinality.  There is little to
     * lose but much to gain, which our strategy reflects.
     */
    if (trace_sort)
        elog(LOG, "varstr_abbrev: aborted abbreviation at %d "
             "(abbrev_distinct: %f, key_distinct: %f, prop_card: %f)",
             memtupcount, abbrev_distinct, key_distinct, sss->prop_card);
 
    return true;
}

References VarStringSortSupport::abbr_card, SortSupportData::abbreviate, Assert(), elog, estimateHyperLogLog(), VarStringSortSupport::full_card, LOG, VarStringSortSupport::prop_card, SortSupportData::ssup_extra, and trace_sort.

Referenced by varstr_sortsupport().

varstr_abbrev_convert()

static Datum varstr_abbrev_convert ( Datum  original, SortSupport  ssup  )

static

Definition at line 1978 of file varlena.c.

{
    const size_t max_prefix_bytes = sizeof(Datum);
    VarStringSortSupport *sss = (VarStringSortSupport *) ssup->ssup_extra;
    VarString  *authoritative = DatumGetVarStringPP(original);
    char       *authoritative_data = VARDATA_ANY(authoritative);
 
    /* working state */
    Datum       res;
    char       *pres;
    int         len;
    uint32      hash;
 
    pres = (char *) &res;
    /* memset(), so any non-overwritten bytes are NUL */
    memset(pres, 0, max_prefix_bytes);
    len = VARSIZE_ANY_EXHDR(authoritative);
 
    /* Get number of bytes, ignoring trailing spaces */
    if (sss->typid == BPCHAROID)
        len = bpchartruelen(authoritative_data, len);
 
    /*
     * If we're using the C collation, use memcpy(), rather than strxfrm(), to
     * abbreviate keys.  The full comparator for the C locale is always
     * memcmp().  It would be incorrect to allow bytea callers (callers that
     * always force the C collation -- bytea isn't a collatable type, but this
     * approach is convenient) to use strxfrm().  This is because bytea
     * strings may contain NUL bytes.  Besides, this should be faster, too.
     *
     * More generally, it's okay that bytea callers can have NUL bytes in
     * strings because abbreviated cmp need not make a distinction between
     * terminating NUL bytes, and NUL bytes representing actual NULs in the
     * authoritative representation.  Hopefully a comparison at or past one
     * abbreviated key's terminating NUL byte will resolve the comparison
     * without consulting the authoritative representation; specifically, some
     * later non-NUL byte in the longer string can resolve the comparison
     * against a subsequent terminating NUL in the shorter string.  There will
     * usually be what is effectively a "length-wise" resolution there and
     * then.
     *
     * If that doesn't work out -- if all bytes in the longer string
     * positioned at or past the offset of the smaller string's (first)
     * terminating NUL are actually representative of NUL bytes in the
     * authoritative binary string (perhaps with some *terminating* NUL bytes
     * towards the end of the longer string iff it happens to still be small)
     * -- then an authoritative tie-breaker will happen, and do the right
     * thing: explicitly consider string length.
     */
    if (sss->collate_c)
        memcpy(pres, authoritative_data, Min(len, max_prefix_bytes));
    else
    {
        Size        bsize;
 
        /*
         * We're not using the C collation, so fall back on strxfrm or ICU
         * analogs.
         */
 
        /* By convention, we use buffer 1 to store and NUL-terminate */
        if (len >= sss->buflen1)
        {
            sss->buflen1 = Max(len + 1, Min(sss->buflen1 * 2, MaxAllocSize));
            sss->buf1 = repalloc(sss->buf1, sss->buflen1);
        }
 
        /* Might be able to reuse strxfrm() blob from last call */
        if (sss->last_len1 == len && sss->cache_blob &&
            memcmp(sss->buf1, authoritative_data, len) == 0)
        {
            memcpy(pres, sss->buf2, Min(max_prefix_bytes, sss->last_len2));
            /* No change affecting cardinality, so no hashing required */
            goto done;
        }
 
        memcpy(sss->buf1, authoritative_data, len);
 
        /*
         * pg_strxfrm() and pg_strxfrm_prefix expect NUL-terminated strings.
         */
        sss->buf1[len] = '\0';
        sss->last_len1 = len;
 
        if (pg_strxfrm_prefix_enabled(sss->locale))
        {
            if (sss->buflen2 < max_prefix_bytes)
            {
                sss->buflen2 = Max(max_prefix_bytes,
                                   Min(sss->buflen2 * 2, MaxAllocSize));
                sss->buf2 = repalloc(sss->buf2, sss->buflen2);
            }
 
            bsize = pg_strxfrm_prefix(sss->buf2, sss->buf1,
                                      max_prefix_bytes, sss->locale);
            sss->last_len2 = bsize;
        }
        else
        {
            /*
             * Loop: Call pg_strxfrm(), possibly enlarge buffer, and try
             * again.  The pg_strxfrm() function leaves the result buffer
             * content undefined if the result did not fit, so we need to
             * retry until everything fits, even though we only need the first
             * few bytes in the end.
             */
            for (;;)
            {
                bsize = pg_strxfrm(sss->buf2, sss->buf1, sss->buflen2,
                                   sss->locale);
 
                sss->last_len2 = bsize;
                if (bsize < sss->buflen2)
                    break;
 
                /*
                 * Grow buffer and retry.
                 */
                sss->buflen2 = Max(bsize + 1,
                                   Min(sss->buflen2 * 2, MaxAllocSize));
                sss->buf2 = repalloc(sss->buf2, sss->buflen2);
            }
        }
 
        /*
         * Every Datum byte is always compared.  This is safe because the
         * strxfrm() blob is itself NUL terminated, leaving no danger of
         * misinterpreting any NUL bytes not intended to be interpreted as
         * logically representing termination.
         *
         * (Actually, even if there were NUL bytes in the blob it would be
         * okay.  See remarks on bytea case above.)
         */
        memcpy(pres, sss->buf2, Min(max_prefix_bytes, bsize));
    }
 
    /*
     * Maintain approximate cardinality of both abbreviated keys and original,
     * authoritative keys using HyperLogLog.  Used as cheap insurance against
     * the worst case, where we do many string transformations for no saving
     * in full strcoll()-based comparisons.  These statistics are used by
     * varstr_abbrev_abort().
     *
     * First, Hash key proper, or a significant fraction of it.  Mix in length
     * in order to compensate for cases where differences are past
     * PG_CACHE_LINE_SIZE bytes, so as to limit the overhead of hashing.
     */
    hash = DatumGetUInt32(hash_any((unsigned char *) authoritative_data,
                                   Min(len, PG_CACHE_LINE_SIZE)));
 
    if (len > PG_CACHE_LINE_SIZE)
        hash ^= DatumGetUInt32(hash_uint32((uint32) len));
 
    addHyperLogLog(&sss->full_card, hash);
 
    /* Hash abbreviated key */
    {
        uint32      tmp;
 
        tmp = DatumGetUInt32(res) ^ (uint32) (DatumGetUInt64(res) >> 32);
        hash = DatumGetUInt32(hash_uint32(tmp));
    }
 
    addHyperLogLog(&sss->abbr_card, hash);
 
    /* Cache result, perhaps saving an expensive strxfrm() call next time */
    sss->cache_blob = true;
done:
 
    /*
     * Byteswap on little-endian machines.
     *
     * This is needed so that ssup_datum_unsigned_cmp() (an unsigned integer
     * 3-way comparator) works correctly on all platforms.  If we didn't do
     * this, the comparator would have to call memcmp() with a pair of
     * pointers to the first byte of each abbreviated key, which is slower.
     */
    res = DatumBigEndianToNative(res);
 
    /* Don't leak memory here */
    if (PointerGetDatum(authoritative) != original)
        pfree(authoritative);
 
    return res;
}

References VarStringSortSupport::abbr_card, addHyperLogLog(), bpchartruelen(), VarStringSortSupport::buf1, VarStringSortSupport::buf2, VarStringSortSupport::buflen1, VarStringSortSupport::buflen2, VarStringSortSupport::cache_blob, VarStringSortSupport::collate_c, DatumBigEndianToNative, DatumGetUInt32(), DatumGetUInt64(), DatumGetVarStringPP, VarStringSortSupport::full_card, hash(), hash_any(), hash_uint32(), VarStringSortSupport::last_len1, VarStringSortSupport::last_len2, len, VarStringSortSupport::locale, Max, MaxAllocSize, Min, pfree(), PG_CACHE_LINE_SIZE, pg_strxfrm(), pg_strxfrm_prefix(), pg_strxfrm_prefix_enabled(), PointerGetDatum(), repalloc(), SortSupportData::ssup_extra, VarStringSortSupport::typid, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

Referenced by varstr_sortsupport().

varstr_cmp()

int varstr_cmp	(	const char *	arg1,
		int	len1,
		const char *	arg2,
		int	len2,
		Oid	collid
	)

Definition at line 1297 of file varlena.c.

{
    int         result;
    pg_locale_t mylocale;
 
    check_collation_set(collid);
 
    mylocale = pg_newlocale_from_collation(collid);
 
    if (mylocale->collate_is_c)
    {
        result = memcmp(arg1, arg2, Min(len1, len2));
        if ((result == 0) && (len1 != len2))
            result = (len1 < len2) ? -1 : 1;
    }
    else
    {
        /*
         * memcmp() can't tell us which of two unequal strings sorts first,
         * but it's a cheap way to tell if they're equal.  Testing shows that
         * memcmp() followed by strcoll() is only trivially slower than
         * strcoll() by itself, so we don't lose much if this doesn't work out
         * very often, and if it does - for example, because there are many
         * equal strings in the input - then we win big by avoiding expensive
         * collation-aware comparisons.
         */
        if (len1 == len2 && memcmp(arg1, arg2, len1) == 0)
            return 0;
 
        result = pg_strncoll(arg1, len1, arg2, len2, mylocale);
 
        /* Break tie if necessary. */
        if (result == 0 && mylocale->deterministic)
        {
            result = memcmp(arg1, arg2, Min(len1, len2));
            if ((result == 0) && (len1 != len2))
                result = (len1 < len2) ? -1 : 1;
        }
    }
 
    return result;
}

References check_collation_set(), pg_locale_struct::collate_is_c, collid, pg_locale_struct::deterministic, Min, pg_newlocale_from_collation(), and pg_strncoll().

Referenced by bpchar_larger(), bpchar_smaller(), bpcharcmp(), bpchareq(), bpcharge(), bpchargt(), bpcharle(), bpcharlt(), bpcharne(), btnametextcmp(), bttextnamecmp(), citextcmp(), compareJsonbScalarValue(), gin_compare_jsonb(), make_greater_string(), namecmp(), nameeqtext(), namenetext(), spg_text_leaf_consistent(), text_cmp(), texteqname(), and textnename().

varstr_sortsupport()

void varstr_sortsupport	(	SortSupport	ssup,
		Oid	typid,
		Oid	collid
	)

Definition at line 1615 of file varlena.c.

{
    bool        abbreviate = ssup->abbreviate;
    bool        collate_c = false;
    VarStringSortSupport *sss;
    pg_locale_t locale;
 
    check_collation_set(collid);
 
    locale = pg_newlocale_from_collation(collid);
 
    /*
     * If possible, set ssup->comparator to a function which can be used to
     * directly compare two datums.  If we can do this, we'll avoid the
     * overhead of a trip through the fmgr layer for every comparison, which
     * can be substantial.
     *
     * Most typically, we'll set the comparator to varlenafastcmp_locale,
     * which uses strcoll() to perform comparisons.  We use that for the
     * BpChar case too, but type NAME uses namefastcmp_locale. However, if
     * LC_COLLATE = C, we can make things quite a bit faster with
     * varstrfastcmp_c, bpcharfastcmp_c, or namefastcmp_c, all of which use
     * memcmp() rather than strcoll().
     */
    if (locale->collate_is_c)
    {
        if (typid == BPCHAROID)
            ssup->comparator = bpcharfastcmp_c;
        else if (typid == NAMEOID)
        {
            ssup->comparator = namefastcmp_c;
            /* Not supporting abbreviation with type NAME, for now */
            abbreviate = false;
        }
        else
            ssup->comparator = varstrfastcmp_c;
 
        collate_c = true;
    }
    else
    {
        /*
         * We use varlenafastcmp_locale except for type NAME.
         */
        if (typid == NAMEOID)
        {
            ssup->comparator = namefastcmp_locale;
            /* Not supporting abbreviation with type NAME, for now */
            abbreviate = false;
        }
        else
            ssup->comparator = varlenafastcmp_locale;
 
        /*
         * Unfortunately, it seems that abbreviation for non-C collations is
         * broken on many common platforms; see pg_strxfrm_enabled().
         *
         * Even apart from the risk of broken locales, it's possible that
         * there are platforms where the use of abbreviated keys should be
         * disabled at compile time.  For example, macOS's strxfrm()
         * implementation is known to not effectively concentrate a
         * significant amount of entropy from the original string in earlier
         * transformed blobs.  It's possible that other supported platforms
         * are similarly encumbered.  So, if we ever get past disabling this
         * categorically, we may still want or need to disable it for
         * particular platforms.
         */
        if (!pg_strxfrm_enabled(locale))
            abbreviate = false;
    }
 
    /*
     * If we're using abbreviated keys, or if we're using a locale-aware
     * comparison, we need to initialize a VarStringSortSupport object. Both
     * cases will make use of the temporary buffers we initialize here for
     * scratch space (and to detect requirement for BpChar semantics from
     * caller), and the abbreviation case requires additional state.
     */
    if (abbreviate || !collate_c)
    {
        sss = palloc(sizeof(VarStringSortSupport));
        sss->buf1 = palloc(TEXTBUFLEN);
        sss->buflen1 = TEXTBUFLEN;
        sss->buf2 = palloc(TEXTBUFLEN);
        sss->buflen2 = TEXTBUFLEN;
        /* Start with invalid values */
        sss->last_len1 = -1;
        sss->last_len2 = -1;
        /* Initialize */
        sss->last_returned = 0;
        if (collate_c)
            sss->locale = NULL;
        else
            sss->locale = locale;
 
        /*
         * To avoid somehow confusing a strxfrm() blob and an original string,
         * constantly keep track of the variety of data that buf1 and buf2
         * currently contain.
         *
         * Comparisons may be interleaved with conversion calls.  Frequently,
         * conversions and comparisons are batched into two distinct phases,
         * but the correctness of caching cannot hinge upon this.  For
         * comparison caching, buffer state is only trusted if cache_blob is
         * found set to false, whereas strxfrm() caching only trusts the state
         * when cache_blob is found set to true.
         *
         * Arbitrarily initialize cache_blob to true.
         */
        sss->cache_blob = true;
        sss->collate_c = collate_c;
        sss->typid = typid;
        ssup->ssup_extra = sss;
 
        /*
         * If possible, plan to use the abbreviated keys optimization.  The
         * core code may switch back to authoritative comparator should
         * abbreviation be aborted.
         */
        if (abbreviate)
        {
            sss->prop_card = 0.20;
            initHyperLogLog(&sss->abbr_card, 10);
            initHyperLogLog(&sss->full_card, 10);
            ssup->abbrev_full_comparator = ssup->comparator;
            ssup->comparator = ssup_datum_unsigned_cmp;
            ssup->abbrev_converter = varstr_abbrev_convert;
            ssup->abbrev_abort = varstr_abbrev_abort;
        }
    }
}

References VarStringSortSupport::abbr_card, SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, SortSupportData::abbreviate, bpcharfastcmp_c(), VarStringSortSupport::buf1, VarStringSortSupport::buf2, VarStringSortSupport::buflen1, VarStringSortSupport::buflen2, VarStringSortSupport::cache_blob, check_collation_set(), VarStringSortSupport::collate_c, collid, SortSupportData::comparator, VarStringSortSupport::full_card, initHyperLogLog(), VarStringSortSupport::last_len1, VarStringSortSupport::last_len2, VarStringSortSupport::last_returned, VarStringSortSupport::locale, locale, namefastcmp_c(), namefastcmp_locale(), palloc(), pg_newlocale_from_collation(), pg_strxfrm_enabled(), VarStringSortSupport::prop_card, ssup_datum_unsigned_cmp(), SortSupportData::ssup_extra, TEXTBUFLEN, VarStringSortSupport::typid, varlenafastcmp_locale(), varstr_abbrev_abort(), varstr_abbrev_convert(), and varstrfastcmp_c().

Referenced by bpchar_sortsupport(), btbpchar_pattern_sortsupport(), btnamesortsupport(), bttext_pattern_sortsupport(), bttextsortsupport(), and bytea_sortsupport().

varstrfastcmp_c()

static int varstrfastcmp_c ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 1751 of file varlena.c.

{
    VarString  *arg1 = DatumGetVarStringPP(x);
    VarString  *arg2 = DatumGetVarStringPP(y);
    char       *a1p,
               *a2p;
    int         len1,
                len2,
                result;
 
    a1p = VARDATA_ANY(arg1);
    a2p = VARDATA_ANY(arg2);
 
    len1 = VARSIZE_ANY_EXHDR(arg1);
    len2 = VARSIZE_ANY_EXHDR(arg2);
 
    result = memcmp(a1p, a2p, Min(len1, len2));
    if ((result == 0) && (len1 != len2))
        result = (len1 < len2) ? -1 : 1;
 
    /* We can't afford to leak memory here. */
    if (PointerGetDatum(arg1) != x)
        pfree(arg1);
    if (PointerGetDatum(arg2) != y)
        pfree(arg2);
 
    return result;
}

References DatumGetVarStringPP, Min, pfree(), PointerGetDatum(), VARDATA_ANY(), VARSIZE_ANY_EXHDR(), x, and y.

Referenced by varstr_sortsupport().

varstrfastcmp_locale()

static int varstrfastcmp_locale ( char *  a1p, int  len1, char *  a2p, int  len2, SortSupport  ssup  )

static

Definition at line 1878 of file varlena.c.

{
    VarStringSortSupport *sss = (VarStringSortSupport *) ssup->ssup_extra;
    int         result;
    bool        arg1_match;
 
    /* Fast pre-check for equality, as discussed in varstr_cmp() */
    if (len1 == len2 && memcmp(a1p, a2p, len1) == 0)
    {
        /*
         * No change in buf1 or buf2 contents, so avoid changing last_len1 or
         * last_len2.  Existing contents of buffers might still be used by
         * next call.
         *
         * It's fine to allow the comparison of BpChar padding bytes here,
         * even though that implies that the memcmp() will usually be
         * performed for BpChar callers (though multibyte characters could
         * still prevent that from occurring).  The memcmp() is still very
         * cheap, and BpChar's funny semantics have us remove trailing spaces
         * (not limited to padding), so we need make no distinction between
         * padding space characters and "real" space characters.
         */
        return 0;
    }
 
    if (sss->typid == BPCHAROID)
    {
        /* Get true number of bytes, ignoring trailing spaces */
        len1 = bpchartruelen(a1p, len1);
        len2 = bpchartruelen(a2p, len2);
    }
 
    if (len1 >= sss->buflen1)
    {
        sss->buflen1 = Max(len1 + 1, Min(sss->buflen1 * 2, MaxAllocSize));
        sss->buf1 = repalloc(sss->buf1, sss->buflen1);
    }
    if (len2 >= sss->buflen2)
    {
        sss->buflen2 = Max(len2 + 1, Min(sss->buflen2 * 2, MaxAllocSize));
        sss->buf2 = repalloc(sss->buf2, sss->buflen2);
    }
 
    /*
     * We're likely to be asked to compare the same strings repeatedly, and
     * memcmp() is so much cheaper than strcoll() that it pays to try to cache
     * comparisons, even though in general there is no reason to think that
     * that will work out (every string datum may be unique).  Caching does
     * not slow things down measurably when it doesn't work out, and can speed
     * things up by rather a lot when it does.  In part, this is because the
     * memcmp() compares data from cachelines that are needed in L1 cache even
     * when the last comparison's result cannot be reused.
     */
    arg1_match = true;
    if (len1 != sss->last_len1 || memcmp(sss->buf1, a1p, len1) != 0)
    {
        arg1_match = false;
        memcpy(sss->buf1, a1p, len1);
        sss->buf1[len1] = '\0';
        sss->last_len1 = len1;
    }
 
    /*
     * If we're comparing the same two strings as last time, we can return the
     * same answer without calling strcoll() again.  This is more likely than
     * it seems (at least with moderate to low cardinality sets), because
     * quicksort compares the same pivot against many values.
     */
    if (len2 != sss->last_len2 || memcmp(sss->buf2, a2p, len2) != 0)
    {
        memcpy(sss->buf2, a2p, len2);
        sss->buf2[len2] = '\0';
        sss->last_len2 = len2;
    }
    else if (arg1_match && !sss->cache_blob)
    {
        /* Use result cached following last actual strcoll() call */
        return sss->last_returned;
    }
 
    result = pg_strcoll(sss->buf1, sss->buf2, sss->locale);
 
    /* Break tie if necessary. */
    if (result == 0 && sss->locale->deterministic)
        result = strcmp(sss->buf1, sss->buf2);
 
    /* Cache result, perhaps saving an expensive strcoll() call next time */
    sss->cache_blob = false;
    sss->last_returned = result;
    return result;
}

References bpchartruelen(), VarStringSortSupport::buf1, VarStringSortSupport::buf2, VarStringSortSupport::buflen1, VarStringSortSupport::buflen2, VarStringSortSupport::cache_blob, pg_locale_struct::deterministic, if(), VarStringSortSupport::last_len1, VarStringSortSupport::last_len2, VarStringSortSupport::last_returned, VarStringSortSupport::locale, Max, MaxAllocSize, Min, pg_strcoll(), repalloc(), SortSupportData::ssup_extra, and VarStringSortSupport::typid.

Referenced by namefastcmp_locale(), and varlenafastcmp_locale().