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 *	str_casefold (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 1931 of file formatting.c.

{
    char       *result;
    int         wasalnum = false;
 
    if (!buff)
        return NULL;
 
    result = pnstrdup(buff, nbytes);
 
    for (char *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 1887 of file formatting.c.

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

References pg_ascii_tolower(), and pnstrdup().

Referenced by asc_tolower_z(), str_casefold(), and str_tolower().

asc_toupper()

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

Definition at line 1909 of file formatting.c.

{
    char       *result;
 
    if (!buff)
        return NULL;
 
    result = pnstrdup(buff, nbytes);
 
    for (char *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 4324 of file formatting.c.

{
    bool        incache;
    size_t      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().

Referenced by jspIsMutableWalker().

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 4163 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_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_casefold()

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

Definition at line 1818 of file formatting.c.

{
    char       *result;
    pg_locale_t mylocale;
 
    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.")));
    }
 
    if (GetDatabaseEncoding() != PG_UTF8)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("Unicode case folding can only be performed if server encoding is UTF8")));
 
    mylocale = pg_newlocale_from_collation(collid);
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (mylocale->ctype_is_c)
    {
        result = asc_tolower(buff, nbytes);
    }
    else
    {
        const char *src = buff;
        size_t      srclen = nbytes;
        size_t      dstsize;
        char       *dst;
        size_t      needed;
 
        /* first try buffer of equal size plus terminating NUL */
        dstsize = srclen + 1;
        dst = palloc(dstsize);
 
        needed = pg_strfold(dst, dstsize, src, srclen, mylocale);
        if (needed + 1 > dstsize)
        {
            /* grow buffer if needed and retry */
            dstsize = needed + 1;
            dst = repalloc(dst, dstsize);
            needed = pg_strfold(dst, dstsize, src, srclen, mylocale);
            Assert(needed + 1 <= dstsize);
        }
 
        Assert(dst[needed] == '\0');
        result = dst;
    }
 
    return result;
}

References asc_tolower(), Assert(), collid, pg_locale_struct::ctype_is_c, ereport, errcode(), errhint(), errmsg(), ERROR, GetDatabaseEncoding(), OidIsValid, palloc(), pg_newlocale_from_collation(), pg_strfold(), PG_UTF8, and repalloc().

Referenced by casefold().

str_initcap()

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

Definition at line 1754 of file formatting.c.

{
    char       *result;
    pg_locale_t mylocale;
 
    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.")));
    }
 
    mylocale = pg_newlocale_from_collation(collid);
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (mylocale->ctype_is_c)
    {
        result = asc_initcap(buff, nbytes);
    }
    else
    {
        const char *src = buff;
        size_t      srclen = nbytes;
        size_t      dstsize;
        char       *dst;
        size_t      needed;
 
        /* first try buffer of equal size plus terminating NUL */
        dstsize = srclen + 1;
        dst = palloc(dstsize);
 
        needed = pg_strtitle(dst, dstsize, src, srclen, mylocale);
        if (needed + 1 > dstsize)
        {
            /* grow buffer if needed and retry */
            dstsize = needed + 1;
            dst = repalloc(dst, dstsize);
            needed = pg_strtitle(dst, dstsize, src, srclen, mylocale);
            Assert(needed + 1 <= dstsize);
        }
 
        Assert(dst[needed] == '\0');
        result = dst;
    }
 
    return result;
}

References asc_initcap(), Assert(), collid, pg_locale_struct::ctype_is_c, ereport, errcode(), errhint(), errmsg(), ERROR, OidIsValid, palloc(), pg_newlocale_from_collation(), pg_strtitle(), and repalloc().

Referenced by initcap(), and str_initcap_z().

str_tolower()

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

Definition at line 1626 of file formatting.c.

{
    char       *result;
    pg_locale_t mylocale;
 
    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.")));
    }
 
    mylocale = pg_newlocale_from_collation(collid);
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (mylocale->ctype_is_c)
    {
        result = asc_tolower(buff, nbytes);
    }
    else
    {
        const char *src = buff;
        size_t      srclen = nbytes;
        size_t      dstsize;
        char       *dst;
        size_t      needed;
 
        /* first try buffer of equal size plus terminating NUL */
        dstsize = srclen + 1;
        dst = palloc(dstsize);
 
        needed = pg_strlower(dst, dstsize, src, srclen, mylocale);
        if (needed + 1 > dstsize)
        {
            /* grow buffer if needed and retry */
            dstsize = needed + 1;
            dst = repalloc(dst, dstsize);
            needed = pg_strlower(dst, dstsize, src, srclen, mylocale);
            Assert(needed + 1 <= dstsize);
        }
 
        Assert(dst[needed] == '\0');
        result = dst;
    }
 
    return result;
}

References asc_tolower(), Assert(), collid, pg_locale_struct::ctype_is_c, ereport, errcode(), errhint(), errmsg(), ERROR, OidIsValid, palloc(), pg_newlocale_from_collation(), pg_strlower(), and repalloc().

Referenced by citext_eq(), citext_hash(), citext_hash_extended(), citext_ne(), citextcmp(), convertPgWchar(), dispell_init(), dispell_lexize(), dsimple_init(), dsimple_lexize(), dsnowball_init(), dsnowball_lexize(), dsynonym_init(), dsynonym_lexize(), dxsyn_lexize(), generate_trgm_only(), generate_wildcard_trgm(), internal_citext_pattern_cmp(), lower(), lowerstr_ctx(), ltree_strncasecmp(), NIImportAffixes(), read_dictionary(), seq_search_localized(), and str_tolower_z().

str_toupper()

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

Definition at line 1690 of file formatting.c.

{
    char       *result;
    pg_locale_t mylocale;
 
    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.")));
    }
 
    mylocale = pg_newlocale_from_collation(collid);
 
    /* C/POSIX collations use this path regardless of database encoding */
    if (mylocale->ctype_is_c)
    {
        result = asc_toupper(buff, nbytes);
    }
    else
    {
        const char *src = buff;
        size_t      srclen = nbytes;
        size_t      dstsize;
        char       *dst;
        size_t      needed;
 
        /* first try buffer of equal size plus terminating NUL */
        dstsize = srclen + 1;
        dst = palloc(dstsize);
 
        needed = pg_strupper(dst, dstsize, src, srclen, mylocale);
        if (needed + 1 > dstsize)
        {
            /* grow buffer if needed and retry */
            dstsize = needed + 1;
            dst = repalloc(dst, dstsize);
            needed = pg_strupper(dst, dstsize, src, srclen, mylocale);
            Assert(needed + 1 <= dstsize);
        }
 
        Assert(dst[needed] == '\0');
        result = dst;
    }
 
    return result;
}

References asc_toupper(), Assert(), collid, pg_locale_struct::ctype_is_c, ereport, errcode(), errhint(), errmsg(), ERROR, OidIsValid, palloc(), pg_newlocale_from_collation(), pg_strupper(), and repalloc().

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