formatting.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
char *	str_tolower (const char *buff, size_t nbytes, Oid collid)
char *	str_toupper (const char *buff, size_t nbytes, Oid collid)
char *	str_initcap (const char *buff, size_t nbytes, Oid collid)
char *	asc_tolower (const char *buff, size_t nbytes)
char *	asc_toupper (const char *buff, size_t nbytes)
char *	asc_initcap (const char *buff, size_t nbytes)
Datum	parse_datetime (text *date_txt, text *fmt, Oid collid, bool strict, Oid *typid, int32 *typmod, int *tz, struct Node *escontext)
bool	datetime_format_has_tz (const char *fmt_str)

Function Documentation

asc_initcap()

char* asc_initcap	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 2204 of file formatting.c.

{
    char       *result;
    char       *p;
    int         wasalnum = false;
 
    if (!buff)
        return NULL;
 
    result = pnstrdup(buff, nbytes);
 
    for (p = result; *p; p++)
    {
        char        c;
 
        if (wasalnum)
            *p = c = pg_ascii_tolower((unsigned char) *p);
        else
            *p = c = pg_ascii_toupper((unsigned char) *p);
        /* we don't trust isalnum() here */
        wasalnum = ((c >= 'A' && c <= 'Z') ||
                    (c >= 'a' && c <= 'z') ||
                    (c >= '0' && c <= '9'));
    }
 
    return result;
}

References pg_ascii_tolower(), pg_ascii_toupper(), and pnstrdup().

Referenced by str_initcap().

asc_tolower()

char* asc_tolower	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 2158 of file formatting.c.

{
    char       *result;
    char       *p;
 
    if (!buff)
        return NULL;
 
    result = pnstrdup(buff, nbytes);
 
    for (p = result; *p; p++)
        *p = pg_ascii_tolower((unsigned char) *p);
 
    return result;
}

References pg_ascii_tolower(), and pnstrdup().

Referenced by asc_tolower_z(), and str_tolower().

asc_toupper()

char* asc_toupper	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 2181 of file formatting.c.

{
    char       *result;
    char       *p;
 
    if (!buff)
        return NULL;
 
    result = pnstrdup(buff, nbytes);
 
    for (p = result; *p; p++)
        *p = pg_ascii_toupper((unsigned char) *p);
 
    return result;
}

References pg_ascii_toupper(), and pnstrdup().

Referenced by asc_toupper_z(), and str_toupper().

datetime_format_has_tz()

bool datetime_format_has_tz

(

const char *

fmt_str

)

Definition at line 4618 of file formatting.c.

{
    bool        incache;
    int         fmt_len = strlen(fmt_str);
    int         result;
    FormatNode *format;
 
    if (fmt_len > DCH_CACHE_SIZE)
    {
        /*
         * Allocate new memory if format picture is bigger than static cache
         * and do not use cache (call parser always)
         */
        incache = false;
 
        format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
 
        parse_format(format, fmt_str, DCH_keywords,
                     DCH_suff, DCH_index, DCH_FLAG, NULL);
    }
    else
    {
        /*
         * Use cache buffers
         */
        DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, false);
 
        incache = true;
        format = ent->format;
    }
 
    result = DCH_datetime_type(format);
 
    if (!incache)
        pfree(format);
 
    return result & DCH_ZONED;
}

References DCH_cache_fetch(), DCH_CACHE_SIZE, DCH_datetime_type(), DCH_FLAG, DCH_index, DCH_keywords, DCH_suff, DCH_ZONED, DCHCacheEntry::format, format, palloc(), parse_format(), and pfree().

parse_datetime()

Datum parse_datetime	(	text *	date_txt,
		text *	fmt,
		Oid	collid,
		bool	strict,
		Oid *	typid,
		int32 *	typmod,
		int *	tz,
		struct Node *	escontext
	)

Definition at line 4455 of file formatting.c.

{
    struct pg_tm tm;
    struct fmt_tz ftz;
    fsec_t      fsec;
    int         fprec;
    uint32      flags;
 
    if (!do_to_timestamp(date_txt, fmt, collid, strict,
                         &tm, &fsec, &ftz, &fprec, &flags, escontext))
        return (Datum) 0;
 
    *typmod = fprec ? fprec : -1;   /* fractional part precision */
 
    if (flags & DCH_DATED)
    {
        if (flags & DCH_TIMED)
        {
            if (flags & DCH_ZONED)
            {
                TimestampTz result;
 
                if (ftz.has_tz)
                {
                    *tz = ftz.gmtoffset;
                }
                else
                {
                    /*
                     * Time zone is present in format string, but not in input
                     * string.  Assuming do_to_timestamp() triggers no error
                     * this should be possible only in non-strict case.
                     */
                    Assert(!strict);
 
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                             errmsg("missing time zone in input string for type timestamptz")));
                }
 
                if (tm2timestamp(&tm, fsec, tz, &result) != 0)
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                             errmsg("timestamptz out of range")));
 
                AdjustTimestampForTypmod(&result, *typmod, escontext);
 
                *typid = TIMESTAMPTZOID;
                return TimestampTzGetDatum(result);
            }
            else
            {
                Timestamp   result;
 
                if (tm2timestamp(&tm, fsec, NULL, &result) != 0)
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                             errmsg("timestamp out of range")));
 
                AdjustTimestampForTypmod(&result, *typmod, escontext);
 
                *typid = TIMESTAMPOID;
                return TimestampGetDatum(result);
            }
        }
        else
        {
            if (flags & DCH_ZONED)
            {
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                         errmsg("datetime format is zoned but not timed")));
            }
            else
            {
                DateADT     result;
 
                /* Prevent overflow in Julian-day routines */
                if (!IS_VALID_JULIAN(tm.tm_year, tm.tm_mon, tm.tm_mday))
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                             errmsg("date out of range: \"%s\"",
                                    text_to_cstring(date_txt))));
 
                result = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) -
                    POSTGRES_EPOCH_JDATE;
 
                /* Now check for just-out-of-range dates */
                if (!IS_VALID_DATE(result))
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                             errmsg("date out of range: \"%s\"",
                                    text_to_cstring(date_txt))));
 
                *typid = DATEOID;
                return DateADTGetDatum(result);
            }
        }
    }
    else if (flags & DCH_TIMED)
    {
        if (flags & DCH_ZONED)
        {
            TimeTzADT  *result = palloc(sizeof(TimeTzADT));
 
            if (ftz.has_tz)
            {
                *tz = ftz.gmtoffset;
            }
            else
            {
                /*
                 * Time zone is present in format string, but not in input
                 * string.  Assuming do_to_timestamp() triggers no error this
                 * should be possible only in non-strict case.
                 */
                Assert(!strict);
 
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                         errmsg("missing time zone in input string for type timetz")));
            }
 
            if (tm2timetz(&tm, fsec, *tz, result) != 0)
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("timetz out of range")));
 
            AdjustTimeForTypmod(&result->time, *typmod);
 
            *typid = TIMETZOID;
            return TimeTzADTPGetDatum(result);
        }
        else
        {
            TimeADT     result;
 
            if (tm2time(&tm, fsec, &result) != 0)
                ereturn(escontext, (Datum) 0,
                        (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                         errmsg("time out of range")));
 
            AdjustTimeForTypmod(&result, *typmod);
 
            *typid = TIMEOID;
            return TimeADTGetDatum(result);
        }
    }
    else
    {
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                 errmsg("datetime format is not dated and not timed")));
    }
}

References AdjustTimeForTypmod(), AdjustTimestampForTypmod(), Assert, collid, date2j(), DateADTGetDatum(), DCH_DATED, DCH_TIMED, DCH_ZONED, do_to_timestamp(), ereturn, errcode(), errmsg(), fmt, fmt_tz::gmtoffset, fmt_tz::has_tz, IS_VALID_DATE, IS_VALID_JULIAN, palloc(), POSTGRES_EPOCH_JDATE, text_to_cstring(), TimeTzADT::time, TimeADTGetDatum(), TimestampGetDatum(), TimestampTzGetDatum(), TimeTzADTPGetDatum(), tm, tm2time(), tm2timestamp(), tm2timetz(), pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

Referenced by executeDateTimeMethod().

str_initcap()

char* str_initcap	(	const char *	buff,
		size_t	nbytes,
		Oid	collid
	)

Definition at line 1973 of file formatting.c.

{
    char       *result;
    int         wasalnum = false;
 
    if (!buff)
        return NULL;
 
    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 %s function",
                        "initcap()"),
                 errhint("Use the COLLATE clause to set the collation explicitly.")));
    }
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (lc_ctype_is_c(collid))
    {
        result = asc_initcap(buff, nbytes);
    }
    else
    {
        pg_locale_t mylocale;
 
        mylocale = pg_newlocale_from_collation(collid);
 
#ifdef USE_ICU
        if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
        {
            int32_t     len_uchar,
                        len_conv;
            UChar      *buff_uchar;
            UChar      *buff_conv;
 
            len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
            len_conv = icu_convert_case(u_strToTitle_default_BI, mylocale,
                                        &buff_conv, buff_uchar, len_uchar);
            icu_from_uchar(&result, buff_conv, len_conv);
            pfree(buff_uchar);
            pfree(buff_conv);
        }
        else
#endif
        if (mylocale && mylocale->provider == COLLPROVIDER_BUILTIN)
        {
            const char *src = buff;
            size_t      srclen = nbytes;
            size_t      dstsize;
            char       *dst;
            size_t      needed;
            struct WordBoundaryState wbstate = {
                .str = src,
                .len = srclen,
                .offset = 0,
                .init = false,
                .prev_alnum = false,
            };
 
            Assert(GetDatabaseEncoding() == PG_UTF8);
 
            /* first try buffer of equal size plus terminating NUL */
            dstsize = srclen + 1;
            dst = palloc(dstsize);
 
            needed = unicode_strtitle(dst, dstsize, src, srclen,
                                      initcap_wbnext, &wbstate);
            if (needed + 1 > dstsize)
            {
                /* reset iterator */
                wbstate.offset = 0;
                wbstate.init = false;
 
                /* grow buffer if needed and retry */
                dstsize = needed + 1;
                dst = repalloc(dst, dstsize);
                needed = unicode_strtitle(dst, dstsize, src, srclen,
                                          initcap_wbnext, &wbstate);
                Assert(needed + 1 == dstsize);
            }
 
            result = dst;
        }
        else
        {
            Assert(!mylocale || mylocale->provider == COLLPROVIDER_LIBC);
 
            if (pg_database_encoding_max_length() > 1)
            {
                wchar_t    *workspace;
                size_t      curr_char;
                size_t      result_size;
 
                /* Overflow paranoia */
                if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));
 
                /* Output workspace cannot have more codes than input bytes */
                workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
 
                char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);
 
                for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
                {
                    if (mylocale)
                    {
                        if (wasalnum)
                            workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
                        else
                            workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
                        wasalnum = iswalnum_l(workspace[curr_char], mylocale->info.lt);
                    }
                    else
                    {
                        if (wasalnum)
                            workspace[curr_char] = towlower(workspace[curr_char]);
                        else
                            workspace[curr_char] = towupper(workspace[curr_char]);
                        wasalnum = iswalnum(workspace[curr_char]);
                    }
                }
 
                /*
                 * Make result large enough; case change might change number
                 * of bytes
                 */
                result_size = curr_char * pg_database_encoding_max_length() + 1;
                result = palloc(result_size);
 
                wchar2char(result, workspace, result_size, mylocale);
                pfree(workspace);
            }
            else
            {
                char       *p;
 
                result = pnstrdup(buff, nbytes);
 
                /*
                 * Note: we assume that toupper_l()/tolower_l() will not be so
                 * broken as to need guard tests.  When using the default
                 * collation, we apply the traditional Postgres behavior that
                 * forces ASCII-style treatment of I/i, but in non-default
                 * collations you get exactly what the collation says.
                 */
                for (p = result; *p; p++)
                {
                    if (mylocale)
                    {
                        if (wasalnum)
                            *p = tolower_l((unsigned char) *p, mylocale->info.lt);
                        else
                            *p = toupper_l((unsigned char) *p, mylocale->info.lt);
                        wasalnum = isalnum_l((unsigned char) *p, mylocale->info.lt);
                    }
                    else
                    {
                        if (wasalnum)
                            *p = pg_tolower((unsigned char) *p);
                        else
                            *p = pg_toupper((unsigned char) *p);
                        wasalnum = isalnum((unsigned char) *p);
                    }
                }
            }
        }
    }
 
    return result;
}

References asc_initcap(), Assert, char2wchar(), collid, ereport, errcode(), errhint(), errmsg(), ERROR, GetDatabaseEncoding(), pg_locale_struct::info, WordBoundaryState::init, initcap_wbnext(), isalnum_l, iswalnum_l, lc_ctype_is_c(), pg_locale_struct::lt, WordBoundaryState::offset, OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_tolower(), pg_toupper(), PG_UTF8, pnstrdup(), pg_locale_struct::provider, repalloc(), WordBoundaryState::str, tolower_l, toupper_l, towlower_l, towupper_l, unicode_strtitle(), and wchar2char().

Referenced by initcap(), and str_initcap_z().

str_tolower()

char* str_tolower	(	const char *	buff,
		size_t	nbytes,
		Oid	collid
	)

Definition at line 1636 of file formatting.c.

{
    char       *result;
 
    if (!buff)
        return NULL;
 
    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 %s function",
                        "lower()"),
                 errhint("Use the COLLATE clause to set the collation explicitly.")));
    }
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (lc_ctype_is_c(collid))
    {
        result = asc_tolower(buff, nbytes);
    }
    else
    {
        pg_locale_t mylocale;
 
        mylocale = pg_newlocale_from_collation(collid);
 
#ifdef USE_ICU
        if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
        {
            int32_t     len_uchar;
            int32_t     len_conv;
            UChar      *buff_uchar;
            UChar      *buff_conv;
 
            len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
            len_conv = icu_convert_case(u_strToLower, mylocale,
                                        &buff_conv, buff_uchar, len_uchar);
            icu_from_uchar(&result, buff_conv, len_conv);
            pfree(buff_uchar);
            pfree(buff_conv);
        }
        else
#endif
        if (mylocale && mylocale->provider == COLLPROVIDER_BUILTIN)
        {
            const char *src = buff;
            size_t      srclen = nbytes;
            size_t      dstsize;
            char       *dst;
            size_t      needed;
 
            Assert(GetDatabaseEncoding() == PG_UTF8);
 
            /* first try buffer of equal size plus terminating NUL */
            dstsize = srclen + 1;
            dst = palloc(dstsize);
 
            needed = unicode_strlower(dst, dstsize, src, srclen);
            if (needed + 1 > dstsize)
            {
                /* grow buffer if needed and retry */
                dstsize = needed + 1;
                dst = repalloc(dst, dstsize);
                needed = unicode_strlower(dst, dstsize, src, srclen);
                Assert(needed + 1 == dstsize);
            }
 
            Assert(dst[needed] == '\0');
            result = dst;
        }
        else
        {
            Assert(!mylocale || mylocale->provider == COLLPROVIDER_LIBC);
 
            if (pg_database_encoding_max_length() > 1)
            {
                wchar_t    *workspace;
                size_t      curr_char;
                size_t      result_size;
 
                /* Overflow paranoia */
                if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));
 
                /* Output workspace cannot have more codes than input bytes */
                workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
 
                char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);
 
                for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
                {
                    if (mylocale)
                        workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
                    else
                        workspace[curr_char] = towlower(workspace[curr_char]);
                }
 
                /*
                 * Make result large enough; case change might change number
                 * of bytes
                 */
                result_size = curr_char * pg_database_encoding_max_length() + 1;
                result = palloc(result_size);
 
                wchar2char(result, workspace, result_size, mylocale);
                pfree(workspace);
            }
            else
            {
                char       *p;
 
                result = pnstrdup(buff, nbytes);
 
                /*
                 * Note: we assume that tolower_l() will not be so broken as
                 * to need an isupper_l() guard test.  When using the default
                 * collation, we apply the traditional Postgres behavior that
                 * forces ASCII-style treatment of I/i, but in non-default
                 * collations you get exactly what the collation says.
                 */
                for (p = result; *p; p++)
                {
                    if (mylocale)
                        *p = tolower_l((unsigned char) *p, mylocale->info.lt);
                    else
                        *p = pg_tolower((unsigned char) *p);
                }
            }
        }
    }
 
    return result;
}

References asc_tolower(), Assert, char2wchar(), collid, ereport, errcode(), errhint(), errmsg(), ERROR, GetDatabaseEncoding(), pg_locale_struct::info, lc_ctype_is_c(), pg_locale_struct::lt, OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_tolower(), PG_UTF8, pnstrdup(), pg_locale_struct::provider, repalloc(), tolower_l, towlower_l, unicode_strlower(), and wchar2char().

Referenced by citext_eq(), citext_hash(), citext_hash_extended(), citext_ne(), citextcmp(), internal_citext_pattern_cmp(), lower(), ltree_strncasecmp(), seq_search_localized(), and str_tolower_z().

str_toupper()

char* str_toupper	(	const char *	buff,
		size_t	nbytes,
		Oid	collid
	)

Definition at line 1784 of file formatting.c.

{
    char       *result;
 
    if (!buff)
        return NULL;
 
    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 %s function",
                        "upper()"),
                 errhint("Use the COLLATE clause to set the collation explicitly.")));
    }
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (lc_ctype_is_c(collid))
    {
        result = asc_toupper(buff, nbytes);
    }
    else
    {
        pg_locale_t mylocale;
 
        mylocale = pg_newlocale_from_collation(collid);
 
#ifdef USE_ICU
        if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
        {
            int32_t     len_uchar,
                        len_conv;
            UChar      *buff_uchar;
            UChar      *buff_conv;
 
            len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
            len_conv = icu_convert_case(u_strToUpper, mylocale,
                                        &buff_conv, buff_uchar, len_uchar);
            icu_from_uchar(&result, buff_conv, len_conv);
            pfree(buff_uchar);
            pfree(buff_conv);
        }
        else
#endif
        if (mylocale && mylocale->provider == COLLPROVIDER_BUILTIN)
        {
            const char *src = buff;
            size_t      srclen = nbytes;
            size_t      dstsize;
            char       *dst;
            size_t      needed;
 
            Assert(GetDatabaseEncoding() == PG_UTF8);
 
            /* first try buffer of equal size plus terminating NUL */
            dstsize = srclen + 1;
            dst = palloc(dstsize);
 
            needed = unicode_strupper(dst, dstsize, src, srclen);
            if (needed + 1 > dstsize)
            {
                /* grow buffer if needed and retry */
                dstsize = needed + 1;
                dst = repalloc(dst, dstsize);
                needed = unicode_strupper(dst, dstsize, src, srclen);
                Assert(needed + 1 == dstsize);
            }
 
            Assert(dst[needed] == '\0');
            result = dst;
        }
        else
        {
            Assert(!mylocale || mylocale->provider == COLLPROVIDER_LIBC);
 
            if (pg_database_encoding_max_length() > 1)
            {
                wchar_t    *workspace;
                size_t      curr_char;
                size_t      result_size;
 
                /* Overflow paranoia */
                if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
                    ereport(ERROR,
                            (errcode(ERRCODE_OUT_OF_MEMORY),
                             errmsg("out of memory")));
 
                /* Output workspace cannot have more codes than input bytes */
                workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
 
                char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);
 
                for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
                {
                    if (mylocale)
                        workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
                    else
                        workspace[curr_char] = towupper(workspace[curr_char]);
                }
 
                /*
                 * Make result large enough; case change might change number
                 * of bytes
                 */
                result_size = curr_char * pg_database_encoding_max_length() + 1;
                result = palloc(result_size);
 
                wchar2char(result, workspace, result_size, mylocale);
                pfree(workspace);
            }
            else
            {
                char       *p;
 
                result = pnstrdup(buff, nbytes);
 
                /*
                 * Note: we assume that toupper_l() will not be so broken as
                 * to need an islower_l() guard test.  When using the default
                 * collation, we apply the traditional Postgres behavior that
                 * forces ASCII-style treatment of I/i, but in non-default
                 * collations you get exactly what the collation says.
                 */
                for (p = result; *p; p++)
                {
                    if (mylocale)
                        *p = toupper_l((unsigned char) *p, mylocale->info.lt);
                    else
                        *p = pg_toupper((unsigned char) *p);
                }
            }
        }
    }
 
    return result;
}

References asc_toupper(), Assert, char2wchar(), collid, ereport, errcode(), errhint(), errmsg(), ERROR, GetDatabaseEncoding(), pg_locale_struct::info, lc_ctype_is_c(), pg_locale_struct::lt, OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_toupper(), PG_UTF8, pnstrdup(), pg_locale_struct::provider, repalloc(), toupper_l, towupper_l, unicode_strupper(), and wchar2char().

Referenced by seq_search_localized(), str_toupper_z(), and upper().