formatting.h File Reference

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

Go to the source code of this file.

Macros
#define	DCH_DATED   0x01
#define	DCH_TIMED   0x02
#define	DCH_ZONED   0x04

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, bool *have_error)
int	datetime_format_flags (const char *fmt_str, bool *have_error)

Macro Definition Documentation

DCH_DATED

#define DCH_DATED   0x01

Definition at line 20 of file formatting.h.

DCH_TIMED

#define DCH_TIMED   0x02

Definition at line 21 of file formatting.h.

DCH_ZONED

#define DCH_ZONED   0x04

Definition at line 22 of file formatting.h.

Function Documentation

asc_initcap()

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

Definition at line 2105 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 2059 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 2082 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_flags()

int datetime_format_flags	(	const char *	fmt_str,
		bool *	have_error
	)

Definition at line 6716 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, have_error);
 
    if (!incache)

Referenced by jspIsMutableWalker().

parse_datetime()

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

Definition at line 4324 of file formatting.c.

{
    struct pg_tm tm;
    fsec_t      fsec;
    int         fprec;
    uint32      flags;
 
    do_to_timestamp(date_txt, fmt, collid, strict,
                    &tm, &fsec, &fprec, &flags, have_error);
    CHECK_ERROR;
 
    *typmod = fprec ? fprec : -1;   /* fractional part precision */
 
    if (flags & DCH_DATED)
    {
        if (flags & DCH_TIMED)
        {
            if (flags & DCH_ZONED)
            {
                TimestampTz result;
 
                if (tm.tm_zone)
                {
                    int         dterr = DecodeTimezone(unconstify(char *, tm.tm_zone), tz);
 
                    if (dterr)
                        DateTimeParseError(dterr, text_to_cstring(date_txt), "timestamptz");
                }
                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);
 
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                                          errmsg("missing time zone in input string for type timestamptz"))));
                }
 
                if (tm2timestamp(&tm, fsec, tz, &result) != 0)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                          errmsg("timestamptz out of range"))));
 
                AdjustTimestampForTypmod(&result, *typmod);
 
                *typid = TIMESTAMPTZOID;
                return TimestampTzGetDatum(result);
            }
            else
            {
                Timestamp   result;
 
                if (tm2timestamp(&tm, fsec, NULL, &result) != 0)
                    RETURN_ERROR(ereport(ERROR,
                                         (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                          errmsg("timestamp out of range"))));
 
                AdjustTimestampForTypmod(&result, *typmod);
 
                *typid = TIMESTAMPOID;
                return TimestampGetDatum(result);
            }
        }
        else
        {
            if (flags & DCH_ZONED)
            {
                RETURN_ERROR(ereport(ERROR,
                                     (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))
                    RETURN_ERROR(ereport(ERROR,
                                         (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))
                    RETURN_ERROR(ereport(ERROR,
                                         (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 (tm.tm_zone)
            {
                int         dterr = DecodeTimezone(unconstify(char *, tm.tm_zone), tz);
 
                if (dterr)
                    RETURN_ERROR(DateTimeParseError(dterr, text_to_cstring(date_txt), "timetz"));
            }
            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);
 
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                                      errmsg("missing time zone in input string for type timetz"))));
            }
 
            if (tm2timetz(&tm, fsec, *tz, result) != 0)
                RETURN_ERROR(ereport(ERROR,
                                     (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)
                RETURN_ERROR(ereport(ERROR,
                                     (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                      errmsg("time out of range"))));
 
            AdjustTimeForTypmod(&result, *typmod);
 
            *typid = TIMEOID;
            return TimeADTGetDatum(result);
        }
    }
    else
    {
        RETURN_ERROR(ereport(ERROR,
                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                              errmsg("datetime format is not dated and not timed"))));
    }
 
on_error:
    return (Datum) 0;
}

References AdjustTimeForTypmod(), AdjustTimestampForTypmod(), Assert(), CHECK_ERROR, date2j(), DateADTGetDatum, DateTimeParseError(), DCH_DATED, DCH_TIMED, DCH_ZONED, DecodeTimezone(), do_to_timestamp(), ereport, errcode(), errmsg(), ERROR, fmt, IS_VALID_DATE, IS_VALID_JULIAN, palloc(), POSTGRES_EPOCH_JDATE, RETURN_ERROR, text_to_cstring(), TimeTzADT::time, TimeADTGetDatum, TimestampGetDatum, TimestampTzGetDatum, TimeTzADTPGetDatum, tm, tm2time(), tm2timestamp(), tm2timetz(), pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, pg_tm::tm_zone, and unconstify.

Referenced by executeDateTimeMethod().

str_initcap()

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

Definition at line 1912 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 (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++)
                {
#ifdef HAVE_LOCALE_T
                    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
#endif
                    {
                        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++)
                {
#ifdef HAVE_LOCALE_T
                    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
#endif
                    {
                        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(), char2wchar(), ereport, errcode(), errhint(), errmsg(), ERROR, pg_locale_struct::info, isalnum_l, iswalnum_l, lc_ctype_is_c(), OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_tolower(), pg_toupper(), pnstrdup(), pg_locale_struct::provider, tolower_l, toupper_l, towlower_l, towupper_l, 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 1668 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 (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++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
                    else
#endif
                        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++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        *p = tolower_l((unsigned char) *p, mylocale->info.lt);
                    else
#endif
                        *p = pg_tolower((unsigned char) *p);
                }
            }
        }
    }
 
    return result;
}

References asc_tolower(), char2wchar(), ereport, errcode(), errhint(), errmsg(), ERROR, pg_locale_struct::info, lc_ctype_is_c(), OidIsValid, palloc(), pfree(), pg_database_encoding_max_length(), pg_newlocale_from_collation(), pg_tolower(), pnstrdup(), pg_locale_struct::provider, tolower_l, towlower_l, 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 1790 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 (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++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
                    else
#endif
                        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++)
                {
#ifdef HAVE_LOCALE_T
                    if (mylocale)
                        *p = toupper_l((unsigned char) *p, mylocale->info.lt);
                    else
#endif
                        *p = pg_toupper((unsigned char) *p);
                }
            }
        }
    }
 
    return result;
}

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

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