formatting.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <unistd.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include "catalog/pg_type.h"
#include "common/int.h"
#include "mb/pg_wchar.h"
#include "nodes/miscnodes.h"
#include "parser/scansup.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/formatting.h"
#include "utils/memutils.h"
#include "utils/numeric.h"
#include "utils/pg_locale.h"
#include "varatt.h"

Include dependency graph for formatting.c:

Go to the source code of this file.

Data Structures
struct	KeySuffix
struct	KeyWord
struct	FormatNode
struct	NUMDesc
struct	DCHCacheEntry
struct	NUMCacheEntry
struct	TmFromChar
struct	fmt_tz
struct	fmt_tm
struct	TmToChar
struct	NUMProc

Macros
#define	DCH_FLAG   0x1 /* DATE-TIME flag */
#define	NUM_FLAG   0x2 /* NUMBER flag */
#define	STD_FLAG   0x4 /* STANDARD flag */
#define	KeyWord_INDEX_SIZE   ('~' - ' ')
#define	KeyWord_INDEX_FILTER(_c)   ((_c) <= ' ' || (_c) >= '~' ? 0 : 1)
#define	DCH_MAX_ITEM_SIZ   12 /* max localized day name */
#define	NUM_MAX_ITEM_SIZ   8 /* roman number (RN has 15 chars) */
#define	ADJUST_YEAR(year, is_interval)   ((is_interval) ? (year) : ((year) <= 0 ? -((year) - 1) : (year)))
#define	A_D_STR   "A.D."
#define	a_d_STR   "a.d."
#define	AD_STR   "AD"
#define	ad_STR   "ad"
#define	B_C_STR   "B.C."
#define	b_c_STR   "b.c."
#define	BC_STR   "BC"
#define	bc_STR   "bc"
#define	A_M_STR   "A.M."
#define	a_m_STR   "a.m."
#define	AM_STR   "AM"
#define	am_STR   "am"
#define	P_M_STR   "P.M."
#define	p_m_STR   "p.m."
#define	PM_STR   "PM"
#define	pm_STR   "pm"
#define	IS_VALID_SUB_COMB(curr, next)
#define	ROMAN_VAL(r)
#define	MAX_ROMAN_LEN   15
#define	NUM_F_DECIMAL   (1 << 1)
#define	NUM_F_LDECIMAL   (1 << 2)
#define	NUM_F_ZERO   (1 << 3)
#define	NUM_F_BLANK   (1 << 4)
#define	NUM_F_FILLMODE   (1 << 5)
#define	NUM_F_LSIGN   (1 << 6)
#define	NUM_F_BRACKET   (1 << 7)
#define	NUM_F_MINUS   (1 << 8)
#define	NUM_F_PLUS   (1 << 9)
#define	NUM_F_ROMAN   (1 << 10)
#define	NUM_F_MULTI   (1 << 11)
#define	NUM_F_PLUS_POST   (1 << 12)
#define	NUM_F_MINUS_POST   (1 << 13)
#define	NUM_F_EEEE   (1 << 14)
#define	IS_DECIMAL(_f)   ((_f)->flag & NUM_F_DECIMAL)
#define	IS_LDECIMAL(_f)   ((_f)->flag & NUM_F_LDECIMAL)
#define	IS_ZERO(_f)   ((_f)->flag & NUM_F_ZERO)
#define	IS_BLANK(_f)   ((_f)->flag & NUM_F_BLANK)
#define	IS_FILLMODE(_f)   ((_f)->flag & NUM_F_FILLMODE)
#define	IS_BRACKET(_f)   ((_f)->flag & NUM_F_BRACKET)
#define	IS_MINUS(_f)   ((_f)->flag & NUM_F_MINUS)
#define	IS_LSIGN(_f)   ((_f)->flag & NUM_F_LSIGN)
#define	IS_PLUS(_f)   ((_f)->flag & NUM_F_PLUS)
#define	IS_ROMAN(_f)   ((_f)->flag & NUM_F_ROMAN)
#define	IS_MULTI(_f)   ((_f)->flag & NUM_F_MULTI)
#define	IS_EEEE(_f)   ((_f)->flag & NUM_F_EEEE)
#define	DCH_CACHE_OVERHEAD    MAXALIGN(sizeof(bool) + sizeof(int))
#define	NUM_CACHE_OVERHEAD    MAXALIGN(sizeof(bool) + sizeof(int) + sizeof(NUMDesc))
#define	DCH_CACHE_SIZE    ((2048 - DCH_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)
#define	NUM_CACHE_SIZE    ((1024 - NUM_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)
#define	DCH_CACHE_ENTRIES   20
#define	NUM_CACHE_ENTRIES   20
#define	DEBUG_TMFC(_X)
#define	DEBUG_TM(_X)
#define	tmtcTm(_X)   (&(_X)->tm)
#define	tmtcTzn(_X)   ((_X)->tzn)
#define	tmtcFsec(_X)   ((_X)->fsec)
#define	COPY_tm(_DST, _SRC)
#define	ZERO_tm(_X)
#define	ZERO_tmtc(_X)
#define	INVALID_FOR_INTERVAL
#define	DCH_SUFFIX_FM   0x01
#define	DCH_SUFFIX_TH   0x02
#define	DCH_SUFFIX_th   0x04
#define	DCH_SUFFIX_SP   0x08
#define	DCH_SUFFIX_TM   0x10
#define	TM_SUFFIX_LEN   2
#define	DCH_DATED   0x01
#define	DCH_TIMED   0x02
#define	DCH_ZONED   0x04
#define	OVERLOAD_TEST   (Np->inout_p >= Np->inout + input_len)
#define	AMOUNT_TEST(s)   (Np->inout_p <= Np->inout + (input_len - (s)))
#define	SKIP_THth(ptr, _suf)
#define	DCH_to_char_fsec(frac_fmt, frac_val)
#define	IS_PREDEC_SPACE(_n)
#define	NUM_TOCHAR_prepare
#define	NUM_TOCHAR_finish

Typedefs
typedef struct TmToChar	TmToChar
typedef struct NUMProc	NUMProc

Enumerations
enum	KeySuffixType { SUFFTYPE_PREFIX = 1 , SUFFTYPE_POSTFIX = 2 }
enum	FromCharDateMode { FROM_CHAR_DATE_NONE = 0 , FROM_CHAR_DATE_GREGORIAN , FROM_CHAR_DATE_ISOWEEK }
enum	FormatNodeType {   NODE_TYPE_END = 1 , NODE_TYPE_ACTION = 2 , NODE_TYPE_CHAR = 3 , NODE_TYPE_SEPARATOR = 4 ,   NODE_TYPE_SPACE = 5 }
enum	TH_Case { TH_UPPER = 1 , TH_LOWER = 2 }
enum	NUMDesc_lsign { NUM_LSIGN_PRE = -1 , NUM_LSIGN_POST = 1 , NUM_LSIGN_NONE = 0 }
enum	DCH_poz {   DCH_A_D , DCH_A_M , DCH_AD , DCH_AM ,   DCH_B_C , DCH_BC , DCH_CC , DCH_DAY ,   DCH_DDD , DCH_DD , DCH_DY , DCH_Day ,   DCH_Dy , DCH_D , DCH_FF1 , DCH_FF2 ,   DCH_FF3 , DCH_FF4 , DCH_FF5 , DCH_FF6 ,   DCH_FX , DCH_HH24 , DCH_HH12 , DCH_HH ,   DCH_IDDD , DCH_ID , DCH_IW , DCH_IYYY ,   DCH_IYY , DCH_IY , DCH_I , DCH_J ,   DCH_MI , DCH_MM , DCH_MONTH , DCH_MON ,   DCH_MS , DCH_Month , DCH_Mon , DCH_OF ,   DCH_P_M , DCH_PM , DCH_Q , DCH_RM ,   DCH_SSSSS , DCH_SSSS , DCH_SS , DCH_TZH ,   DCH_TZM , DCH_TZ , DCH_US , DCH_WW ,   DCH_W , DCH_Y_YYY , DCH_YYYY , DCH_YYY ,   DCH_YY , DCH_Y , DCH_a_d , DCH_a_m ,   DCH_ad , DCH_am , DCH_b_c , DCH_bc ,   DCH_cc , DCH_day , DCH_ddd , DCH_dd ,   DCH_dy , DCH_d , DCH_ff1 , DCH_ff2 ,   DCH_ff3 , DCH_ff4 , DCH_ff5 , DCH_ff6 ,   DCH_fx , DCH_hh24 , DCH_hh12 , DCH_hh ,   DCH_iddd , DCH_id , DCH_iw , DCH_iyyy ,   DCH_iyy , DCH_iy , DCH_i , DCH_j ,   DCH_mi , DCH_mm , DCH_month , DCH_mon ,   DCH_ms , DCH_of , DCH_p_m , DCH_pm ,   DCH_q , DCH_rm , DCH_sssss , DCH_ssss ,   DCH_ss , DCH_tzh , DCH_tzm , DCH_tz ,   DCH_us , DCH_ww , DCH_w , DCH_y_yyy ,   DCH_yyyy , DCH_yyy , DCH_yy , DCH_y ,   _DCH_last_ }
enum	NUM_poz {   NUM_COMMA , NUM_DEC , NUM_0 , NUM_9 ,   NUM_B , NUM_C , NUM_D , NUM_E ,   NUM_FM , NUM_G , NUM_L , NUM_MI ,   NUM_PL , NUM_PR , NUM_RN , NUM_SG ,   NUM_SP , NUM_S , NUM_TH , NUM_V ,   NUM_b , NUM_c , NUM_d , NUM_e ,   NUM_fm , NUM_g , NUM_l , NUM_mi ,   NUM_pl , NUM_pr , NUM_rn , NUM_sg ,   NUM_sp , NUM_s , NUM_th , NUM_v ,   _NUM_last_ }

Functions
static bool	IS_SUFFIX_TH (uint8 _s)
static bool	IS_SUFFIX_th (uint8 _s)
static bool	IS_SUFFIX_THth (uint8 _s)
static enum TH_Case	SUFFIX_TH_TYPE (uint8 _s)
static bool	IS_SUFFIX_FM (uint8 _s)
static bool	IS_SUFFIX_TM (uint8 _s)
static const KeyWord *	index_seq_search (const char *str, const KeyWord *kw, const int *index)
static const KeySuffix *	suff_search (const char *str, const KeySuffix *suf, enum KeySuffixType type)
static bool	is_separator_char (const char *str)
static void	NUMDesc_prepare (NUMDesc *num, FormatNode *n)
static void	parse_format (FormatNode *node, const char *str, const KeyWord *kw, const KeySuffix *suf, const int *index, uint32 flags, NUMDesc *Num)
static void	DCH_to_char (FormatNode *node, bool is_interval, TmToChar *in, char *out, Oid collid)
static void	DCH_from_char (FormatNode *node, const char *in, TmFromChar *out, Oid collid, bool std, Node *escontext)
static const char *	get_th (const char *num, enum TH_Case type)
static char *	str_numth (char *dest, const char *num, enum TH_Case type)
static int	adjust_partial_year_to_2020 (int year)
static size_t	strspace_len (const char *str)
static bool	from_char_set_mode (TmFromChar *tmfc, const FromCharDateMode mode, Node *escontext)
static bool	from_char_set_int (int *dest, const int value, const FormatNode *node, Node *escontext)
static int	from_char_parse_int_len (int *dest, const char **src, const size_t len, FormatNode *node, Node *escontext)
static int	from_char_parse_int (int *dest, const char **src, FormatNode *node, Node *escontext)
static int	seq_search_ascii (const char *name, const char *const *array, size_t *len)
static int	seq_search_localized (const char *name, char **array, size_t *len, Oid collid)
static bool	from_char_seq_search (int *dest, const char **src, const char *const *array, char **localized_array, Oid collid, FormatNode *node, Node *escontext)
static bool	do_to_timestamp (const text *date_txt, const text *fmt, Oid collid, bool std, struct pg_tm *tm, fsec_t *fsec, struct fmt_tz *tz, int *fprec, uint32 *flags, Node *escontext)
static void	fill_str (char *str, int c, int max)
static FormatNode *	NUM_cache (int len, NUMDesc *Num, const text *pars_str, bool *shouldFree)
static char *	int_to_roman (int number)
static int	roman_to_int (NUMProc *Np, size_t input_len)
static void	NUM_prepare_locale (NUMProc *Np)
static const char *	get_last_relevant_decnum (const char *num)
static void	NUM_numpart_from_char (NUMProc *Np, int id, size_t input_len)
static void	NUM_numpart_to_char (NUMProc *Np, int id)
static char *	NUM_processor (FormatNode *node, NUMDesc *Num, char *inout, char *number, size_t input_len, int to_char_out_pre_spaces, int sign, bool is_to_char, Oid collid)
static DCHCacheEntry *	DCH_cache_getnew (const char *str, bool std)
static DCHCacheEntry *	DCH_cache_search (const char *str, bool std)
static DCHCacheEntry *	DCH_cache_fetch (const char *str, bool std)
static NUMCacheEntry *	NUM_cache_getnew (const char *str)
static NUMCacheEntry *	NUM_cache_search (const char *str)
static NUMCacheEntry *	NUM_cache_fetch (const char *str)
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)
static char *	str_tolower_z (const char *buff, Oid collid)
static char *	str_toupper_z (const char *buff, Oid collid)
static char *	str_initcap_z (const char *buff, Oid collid)
static char *	asc_tolower_z (const char *buff)
static char *	asc_toupper_z (const char *buff)
static bool	is_next_separator (FormatNode *n)
static void	DCH_prevent_counter_overflow (void)
static int	DCH_datetime_type (FormatNode *node)
static text *	datetime_to_char_body (TmToChar *tmtc, const text *fmt, bool is_interval, Oid collid)
Datum	timestamp_to_char (PG_FUNCTION_ARGS)
Datum	timestamptz_to_char (PG_FUNCTION_ARGS)
Datum	interval_to_char (PG_FUNCTION_ARGS)
Datum	to_timestamp (PG_FUNCTION_ARGS)
Datum	to_date (PG_FUNCTION_ARGS)
Datum	parse_datetime (text *date_txt, text *fmt, Oid collid, bool strict, Oid *typid, int32 *typmod, int *tz, Node *escontext)
bool	datetime_format_has_tz (const char *fmt_str)
static void	NUM_prevent_counter_overflow (void)
static void	NUM_eat_non_data_chars (NUMProc *Np, int n, size_t input_len)
Datum	numeric_to_number (PG_FUNCTION_ARGS)
Datum	numeric_to_char (PG_FUNCTION_ARGS)
Datum	int4_to_char (PG_FUNCTION_ARGS)
Datum	int8_to_char (PG_FUNCTION_ARGS)
Datum	float4_to_char (PG_FUNCTION_ARGS)
Datum	float8_to_char (PG_FUNCTION_ARGS)

Variables
static const char *const	months_full []
static const char *const	days_short []
static const char *const	adbc_strings [] = {ad_STR, bc_STR, AD_STR, BC_STR, NULL}
static const char *const	adbc_strings_long [] = {a_d_STR, b_c_STR, A_D_STR, B_C_STR, NULL}
static const char *const	ampm_strings [] = {am_STR, pm_STR, AM_STR, PM_STR, NULL}
static const char *const	ampm_strings_long [] = {a_m_STR, p_m_STR, A_M_STR, P_M_STR, NULL}
static const char *const	rm_months_upper []
static const char *const	rm_months_lower []
static const char *const	rm1 [] = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", NULL}
static const char *const	rm10 [] = {"X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", NULL}
static const char *const	rm100 [] = {"C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", NULL}
static const char *const	numTH [] = {"ST", "ND", "RD", "TH", NULL}
static const char *const	numth [] = {"st", "nd", "rd", "th", NULL}
static DCHCacheEntry *	DCHCache [DCH_CACHE_ENTRIES]
static int	n_DCHCache = 0
static int	DCHCounter = 0
static NUMCacheEntry *	NUMCache [NUM_CACHE_ENTRIES]
static int	n_NUMCache = 0
static int	NUMCounter = 0
static const KeySuffix	DCH_suff []
static const KeyWord	DCH_keywords []
static const KeyWord	NUM_keywords []
static const int	DCH_index [KeyWord_INDEX_SIZE]
static const int	NUM_index [KeyWord_INDEX_SIZE]

Macro Definition Documentation

A_D_STR

#define A_D_STR   "A.D."

Definition at line 187 of file formatting.c.

a_d_STR

#define a_d_STR   "a.d."

Definition at line 188 of file formatting.c.

A_M_STR

#define A_M_STR   "A.M."

Definition at line 213 of file formatting.c.

a_m_STR

#define a_m_STR   "a.m."

Definition at line 214 of file formatting.c.

AD_STR

#define AD_STR   "AD"

Definition at line 189 of file formatting.c.

ad_STR

#define ad_STR   "ad"

Definition at line 190 of file formatting.c.

ADJUST_YEAR

#define ADJUST_YEAR	(		year,
			is_interval
	)		((is_interval) ? (year) : ((year) <= 0 ? -((year) - 1) : (year)))

Definition at line 185 of file formatting.c.

AM_STR

#define AM_STR   "AM"

Definition at line 215 of file formatting.c.

am_STR

#define am_STR   "am"

Definition at line 216 of file formatting.c.

AMOUNT_TEST

#define AMOUNT_TEST

(

s

)

(Np->inout_p <= Np->inout + (input_len - (s)))

Definition at line 1063 of file formatting.c.

B_C_STR

#define B_C_STR   "B.C."

Definition at line 192 of file formatting.c.

b_c_STR

#define b_c_STR   "b.c."

Definition at line 193 of file formatting.c.

BC_STR

#define BC_STR   "BC"

Definition at line 194 of file formatting.c.

bc_STR

#define bc_STR   "bc"

Definition at line 195 of file formatting.c.

COPY_tm

#define COPY_tm	(		_DST,
			_SRC
	)

Value:

do {    \
    (_DST)->tm_sec = (_SRC)->tm_sec; \
    (_DST)->tm_min = (_SRC)->tm_min; \
    (_DST)->tm_hour = (_SRC)->tm_hour; \
    (_DST)->tm_mday = (_SRC)->tm_mday; \
    (_DST)->tm_mon = (_SRC)->tm_mon; \
    (_DST)->tm_year = (_SRC)->tm_year; \
    (_DST)->tm_wday = (_SRC)->tm_wday; \
    (_DST)->tm_yday = (_SRC)->tm_yday; \
    (_DST)->tm_gmtoff = (_SRC)->tm_gmtoff; \
} while(0)

Definition at line 503 of file formatting.c.

DCH_CACHE_ENTRIES

#define DCH_CACHE_ENTRIES   20

Definition at line 379 of file formatting.c.

DCH_CACHE_OVERHEAD

#define DCH_CACHE_OVERHEAD    MAXALIGN(sizeof(bool) + sizeof(int))

Definition at line 369 of file formatting.c.

DCH_CACHE_SIZE

#define DCH_CACHE_SIZE    ((2048 - DCH_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)

Definition at line 374 of file formatting.c.

DCH_DATED

#define DCH_DATED   0x01

Definition at line 1053 of file formatting.c.

DCH_FLAG

#define DCH_FLAG   0x1 /* DATE-TIME flag */

Definition at line 90 of file formatting.c.

DCH_MAX_ITEM_SIZ

#define DCH_MAX_ITEM_SIZ   12 /* max localized day name */

Definition at line 103 of file formatting.c.

DCH_SUFFIX_FM

#define DCH_SUFFIX_FM   0x01

Definition at line 550 of file formatting.c.

DCH_SUFFIX_SP

#define DCH_SUFFIX_SP   0x08

Definition at line 553 of file formatting.c.

DCH_SUFFIX_TH

#define DCH_SUFFIX_TH   0x02

Definition at line 551 of file formatting.c.

DCH_SUFFIX_th

#define DCH_SUFFIX_th   0x04

Definition at line 552 of file formatting.c.

DCH_SUFFIX_TM

#define DCH_SUFFIX_TM   0x10

Definition at line 554 of file formatting.c.

DCH_TIMED

#define DCH_TIMED   0x02

Definition at line 1054 of file formatting.c.

DCH_to_char_fsec

#define DCH_to_char_fsec	(		frac_fmt,
			frac_val
	)

Value:

                sprintf(s, frac_fmt, (int) (frac_val)); \
                if (IS_SUFFIX_THth(n->suffix)) \
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix)); \
                s += strlen(s)

DCH_ZONED

#define DCH_ZONED   0x04

Definition at line 1055 of file formatting.c.

DEBUG_TM

#define DEBUG_TM

(

_X

)

Definition at line 468 of file formatting.c.

DEBUG_TMFC

#define DEBUG_TMFC

(

_X

)

Definition at line 467 of file formatting.c.

INVALID_FOR_INTERVAL

#define INVALID_FOR_INTERVAL

Value:

do { \
    if (is_interval) \
        ereport(ERROR, \
                (errcode(ERRCODE_INVALID_DATETIME_FORMAT), \
                 errmsg("invalid format specification for an interval value"), \
                 errhint("Intervals are not tied to specific calendar dates."))); \
} while(0)

Definition at line 534 of file formatting.c.

IS_BLANK

#define IS_BLANK

(

_f

)

((_f)->flag & NUM_F_BLANK)

Definition at line 342 of file formatting.c.

IS_BRACKET

#define IS_BRACKET

(

_f

)

((_f)->flag & NUM_F_BRACKET)

Definition at line 344 of file formatting.c.

IS_DECIMAL

#define IS_DECIMAL

(

_f

)

((_f)->flag & NUM_F_DECIMAL)

Definition at line 339 of file formatting.c.

IS_EEEE

#define IS_EEEE

(

_f

)

((_f)->flag & NUM_F_EEEE)

Definition at line 350 of file formatting.c.

IS_FILLMODE

#define IS_FILLMODE

(

_f

)

((_f)->flag & NUM_F_FILLMODE)

Definition at line 343 of file formatting.c.

IS_LDECIMAL

#define IS_LDECIMAL

(

_f

)

((_f)->flag & NUM_F_LDECIMAL)

Definition at line 340 of file formatting.c.

IS_LSIGN

#define IS_LSIGN

(

_f

)

((_f)->flag & NUM_F_LSIGN)

Definition at line 346 of file formatting.c.

IS_MINUS

#define IS_MINUS

(

_f

)

((_f)->flag & NUM_F_MINUS)

Definition at line 345 of file formatting.c.

IS_MULTI

#define IS_MULTI

(

_f

)

((_f)->flag & NUM_F_MULTI)

Definition at line 349 of file formatting.c.

IS_PLUS

#define IS_PLUS

(

_f

)

((_f)->flag & NUM_F_PLUS)

Definition at line 347 of file formatting.c.

IS_PREDEC_SPACE

#define IS_PREDEC_SPACE

(

_n

)

Value:

        (IS_ZERO((_n)->Num)==false && \
         (_n)->number == (_n)->number_p && \
         *(_n)->number == '0' && \
                 (_n)->Num->post != 0)

Definition at line 5525 of file formatting.c.

IS_ROMAN

#define IS_ROMAN

(

_f

)

((_f)->flag & NUM_F_ROMAN)

Definition at line 348 of file formatting.c.

IS_VALID_SUB_COMB

#define IS_VALID_SUB_COMB	(		curr,
			next
	)

Value:

    (((curr) == 'I' && ((next) == 'V' || (next) == 'X')) || \
     ((curr) == 'X' && ((next) == 'L' || (next) == 'C')) || \
     ((curr) == 'C' && ((next) == 'D' || (next) == 'M')))

Definition at line 258 of file formatting.c.

IS_ZERO

#define IS_ZERO

(

_f

)

((_f)->flag & NUM_F_ZERO)

Definition at line 341 of file formatting.c.

KeyWord_INDEX_FILTER

#define KeyWord_INDEX_FILTER

(

_c

)

((_c) <= ' ' || (_c) >= '~' ? 0 : 1)

Definition at line 98 of file formatting.c.

KeyWord_INDEX_SIZE

#define KeyWord_INDEX_SIZE   ('~' - ' ')

Definition at line 97 of file formatting.c.

MAX_ROMAN_LEN

#define MAX_ROMAN_LEN   15

Definition at line 278 of file formatting.c.

NUM_CACHE_ENTRIES

#define NUM_CACHE_ENTRIES   20

Definition at line 380 of file formatting.c.

NUM_CACHE_OVERHEAD

#define NUM_CACHE_OVERHEAD    MAXALIGN(sizeof(bool) + sizeof(int) + sizeof(NUMDesc))

Definition at line 371 of file formatting.c.

NUM_CACHE_SIZE

#define NUM_CACHE_SIZE    ((1024 - NUM_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)

Definition at line 376 of file formatting.c.

NUM_F_BLANK

#define NUM_F_BLANK   (1 << 4)

Definition at line 324 of file formatting.c.

NUM_F_BRACKET

#define NUM_F_BRACKET   (1 << 7)

Definition at line 327 of file formatting.c.

NUM_F_DECIMAL

#define NUM_F_DECIMAL   (1 << 1)

Definition at line 321 of file formatting.c.

NUM_F_EEEE

#define NUM_F_EEEE   (1 << 14)

Definition at line 334 of file formatting.c.

NUM_F_FILLMODE

#define NUM_F_FILLMODE   (1 << 5)

Definition at line 325 of file formatting.c.

NUM_F_LDECIMAL

#define NUM_F_LDECIMAL   (1 << 2)

Definition at line 322 of file formatting.c.

NUM_F_LSIGN

#define NUM_F_LSIGN   (1 << 6)

Definition at line 326 of file formatting.c.

NUM_F_MINUS

#define NUM_F_MINUS   (1 << 8)

Definition at line 328 of file formatting.c.

NUM_F_MINUS_POST

#define NUM_F_MINUS_POST   (1 << 13)

Definition at line 333 of file formatting.c.

NUM_F_MULTI

#define NUM_F_MULTI   (1 << 11)

Definition at line 331 of file formatting.c.

NUM_F_PLUS

#define NUM_F_PLUS   (1 << 9)

Definition at line 329 of file formatting.c.

NUM_F_PLUS_POST

#define NUM_F_PLUS_POST   (1 << 12)

Definition at line 332 of file formatting.c.

NUM_F_ROMAN

#define NUM_F_ROMAN   (1 << 10)

Definition at line 330 of file formatting.c.

NUM_F_ZERO

#define NUM_F_ZERO   (1 << 3)

Definition at line 323 of file formatting.c.

NUM_FLAG

#define NUM_FLAG   0x2 /* NUMBER flag */

Definition at line 91 of file formatting.c.

NUM_MAX_ITEM_SIZ

#define NUM_MAX_ITEM_SIZ   8 /* roman number (RN has 15 chars) */

Definition at line 104 of file formatting.c.

NUM_TOCHAR_finish

#define NUM_TOCHAR_finish

Value:

do { \
    size_t  len; \
									\
	NUM_processor(format, &Num, VARDATA(result), numstr, 0, out_pre_spaces, sign, true, PG_GET_COLLATION()); \
									\
	if (shouldFree)                    \
        pfree(format);              \
                                    \
    /*                              \
     * Convert null-terminated representation of result to standard text. \
     * The result is usually much bigger than it needs to be, but there \
     * seems little point in realloc'ing it smaller. \
     */                             \
    len = strlen(VARDATA(result));  \
    SET_VARSIZE(result, len + VARHDRSZ); \
} while (0)

Definition at line 6217 of file formatting.c.

NUM_TOCHAR_prepare

#define NUM_TOCHAR_prepare

Value:

do { \
    int len = VARSIZE_ANY_EXHDR(fmt); \
    if (len <= 0 || len >= (INT_MAX-VARHDRSZ)/NUM_MAX_ITEM_SIZ)     \
        PG_RETURN_TEXT_P(cstring_to_text("")); \
    result  = (text *) palloc0((len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ);    \
    format  = NUM_cache(len, &Num, fmt, &shouldFree);       \
} while (0)

Definition at line 6205 of file formatting.c.

OVERLOAD_TEST

#define OVERLOAD_TEST   (Np->inout_p >= Np->inout + input_len)

Definition at line 1062 of file formatting.c.

P_M_STR

#define P_M_STR   "P.M."

Definition at line 218 of file formatting.c.

p_m_STR

#define p_m_STR   "p.m."

Definition at line 219 of file formatting.c.

PM_STR

#define PM_STR   "PM"

Definition at line 220 of file formatting.c.

pm_STR

#define pm_STR   "pm"

Definition at line 221 of file formatting.c.

ROMAN_VAL

#define ROMAN_VAL

(

r

)

Value:

    ((r) == 'I' ? 1 : \
     (r) == 'V' ? 5 : \
     (r) == 'X' ? 10 : \
     (r) == 'L' ? 50 : \
     (r) == 'C' ? 100 : \
     (r) == 'D' ? 500 : \
     (r) == 'M' ? 1000 : 0)

Definition at line 266 of file formatting.c.

SKIP_THth

#define SKIP_THth	(		ptr,
			_suf
	)

Value:

    do { \
        if (IS_SUFFIX_THth(_suf)) \
        { \
            if (*(ptr)) (ptr) += pg_mblen(ptr); \
            if (*(ptr)) (ptr) += pg_mblen(ptr); \
        } \
    } while (0)

Definition at line 1991 of file formatting.c.

STD_FLAG

#define STD_FLAG   0x4 /* STANDARD flag */

Definition at line 92 of file formatting.c.

TM_SUFFIX_LEN

#define TM_SUFFIX_LEN   2

Definition at line 599 of file formatting.c.

tmtcFsec

#define tmtcFsec

(

_X

)

((_X)->fsec)

Definition at line 500 of file formatting.c.

tmtcTm

#define tmtcTm

(

_X

)

(&(_X)->tm)

Definition at line 498 of file formatting.c.

tmtcTzn

#define tmtcTzn

(

_X

)

((_X)->tzn)

Definition at line 499 of file formatting.c.

ZERO_tm

#define ZERO_tm

(

_X

)

Value:

do {    \
    memset(_X, 0, sizeof(*(_X))); \
    (_X)->tm_mday = (_X)->tm_mon = 1; \
} while(0)

Definition at line 517 of file formatting.c.

ZERO_tmtc

#define ZERO_tmtc

(

_X

)

Value:

do { \
    ZERO_tm( tmtcTm(_X) ); \
    tmtcFsec(_X) = 0; \
    tmtcTzn(_X) = NULL; \
} while(0)

Definition at line 523 of file formatting.c.

Typedef Documentation

NUMProc

typedef struct NUMProc NUMProc

TmToChar

typedef struct TmToChar TmToChar

Enumeration Type Documentation

DCH_poz

enum DCH_poz

Enumerator
DCH_A_D
DCH_A_M
DCH_AD
DCH_AM
DCH_B_C
DCH_BC
DCH_CC
DCH_DAY
DCH_DDD
DCH_DD
DCH_DY
DCH_Day
DCH_Dy
DCH_D
DCH_FF1
DCH_FF2
DCH_FF3
DCH_FF4
DCH_FF5
DCH_FF6
DCH_FX
DCH_HH24
DCH_HH12
DCH_HH
DCH_IDDD
DCH_ID
DCH_IW
DCH_IYYY
DCH_IYY
DCH_IY
DCH_I
DCH_J
DCH_MI
DCH_MM
DCH_MONTH
DCH_MON
DCH_MS
DCH_Month
DCH_Mon
DCH_OF
DCH_P_M
DCH_PM
DCH_Q
DCH_RM
DCH_SSSSS
DCH_SSSS
DCH_SS
DCH_TZH
DCH_TZM
DCH_TZ
DCH_US
DCH_WW
DCH_W
DCH_Y_YYY
DCH_YYYY
DCH_YYY
DCH_YY
DCH_Y
DCH_a_d
DCH_a_m
DCH_ad
DCH_am
DCH_b_c
DCH_bc
DCH_cc
DCH_day
DCH_ddd
DCH_dd
DCH_dy
DCH_d
DCH_ff1
DCH_ff2
DCH_ff3
DCH_ff4
DCH_ff5
DCH_ff6
DCH_fx
DCH_hh24
DCH_hh12
DCH_hh
DCH_iddd
DCH_id
DCH_iw
DCH_iyyy
DCH_iyy
DCH_iy
DCH_i
DCH_j
DCH_mi
DCH_mm
DCH_month
DCH_mon
DCH_ms
DCH_of
DCH_p_m
DCH_pm
DCH_q
DCH_rm
DCH_sssss
DCH_ssss
DCH_ss
DCH_tzh
DCH_tzm
DCH_tz
DCH_us
DCH_ww
DCH_w
DCH_y_yyy
DCH_yyyy
DCH_yyy
DCH_yy
DCH_y
_DCH_last_

Definition at line 640 of file formatting.c.

{
    DCH_A_D,
    DCH_A_M,
    DCH_AD,
    DCH_AM,
    DCH_B_C,
    DCH_BC,
    DCH_CC,
    DCH_DAY,
    DCH_DDD,
    DCH_DD,
    DCH_DY,
    DCH_Day,
    DCH_Dy,
    DCH_D,
    DCH_FF1,                    /* FFn codes must be consecutive */
    DCH_FF2,
    DCH_FF3,
    DCH_FF4,
    DCH_FF5,
    DCH_FF6,
    DCH_FX,                     /* global suffix */
    DCH_HH24,
    DCH_HH12,
    DCH_HH,
    DCH_IDDD,
    DCH_ID,
    DCH_IW,
    DCH_IYYY,
    DCH_IYY,
    DCH_IY,
    DCH_I,
    DCH_J,
    DCH_MI,
    DCH_MM,
    DCH_MONTH,
    DCH_MON,
    DCH_MS,
    DCH_Month,
    DCH_Mon,
    DCH_OF,
    DCH_P_M,
    DCH_PM,
    DCH_Q,
    DCH_RM,
    DCH_SSSSS,
    DCH_SSSS,
    DCH_SS,
    DCH_TZH,
    DCH_TZM,
    DCH_TZ,
    DCH_US,
    DCH_WW,
    DCH_W,
    DCH_Y_YYY,
    DCH_YYYY,
    DCH_YYY,
    DCH_YY,
    DCH_Y,
    DCH_a_d,
    DCH_a_m,
    DCH_ad,
    DCH_am,
    DCH_b_c,
    DCH_bc,
    DCH_cc,
    DCH_day,
    DCH_ddd,
    DCH_dd,
    DCH_dy,
    DCH_d,
    DCH_ff1,
    DCH_ff2,
    DCH_ff3,
    DCH_ff4,
    DCH_ff5,
    DCH_ff6,
    DCH_fx,
    DCH_hh24,
    DCH_hh12,
    DCH_hh,
    DCH_iddd,
    DCH_id,
    DCH_iw,
    DCH_iyyy,
    DCH_iyy,
    DCH_iy,
    DCH_i,
    DCH_j,
    DCH_mi,
    DCH_mm,
    DCH_month,
    DCH_mon,
    DCH_ms,
    DCH_of,
    DCH_p_m,
    DCH_pm,
    DCH_q,
    DCH_rm,
    DCH_sssss,
    DCH_ssss,
    DCH_ss,
    DCH_tzh,
    DCH_tzm,
    DCH_tz,
    DCH_us,
    DCH_ww,
    DCH_w,
    DCH_y_yyy,
    DCH_yyyy,
    DCH_yyy,
    DCH_yy,
    DCH_y,
 
    /* last */
    _DCH_last_
}           DCH_poz;

FormatNodeType

enum FormatNodeType

Enumerator
NODE_TYPE_END
NODE_TYPE_ACTION
NODE_TYPE_CHAR
NODE_TYPE_SEPARATOR
NODE_TYPE_SPACE

Definition at line 147 of file formatting.c.

{
    NODE_TYPE_END = 1,
    NODE_TYPE_ACTION = 2,
    NODE_TYPE_CHAR = 3,
    NODE_TYPE_SEPARATOR = 4,
    NODE_TYPE_SPACE = 5,
};

FromCharDateMode

enum FromCharDateMode

Enumerator
FROM_CHAR_DATE_NONE
FROM_CHAR_DATE_GREGORIAN
FROM_CHAR_DATE_ISOWEEK

Definition at line 131 of file formatting.c.

{
    FROM_CHAR_DATE_NONE = 0,    /* Value does not affect date mode. */
    FROM_CHAR_DATE_GREGORIAN,   /* Gregorian (day, month, year) style date */
    FROM_CHAR_DATE_ISOWEEK,     /* ISO 8601 week date */
} FromCharDateMode;

KeySuffixType

enum KeySuffixType

Enumerator
SUFFTYPE_PREFIX
SUFFTYPE_POSTFIX

Definition at line 111 of file formatting.c.

{
    SUFFTYPE_PREFIX = 1,
    SUFFTYPE_POSTFIX = 2,
};

NUM_poz

enum NUM_poz

Enumerator
NUM_COMMA
NUM_DEC
NUM_0
NUM_9
NUM_B
NUM_C
NUM_D
NUM_E
NUM_FM
NUM_G
NUM_L
NUM_MI
NUM_PL
NUM_PR
NUM_RN
NUM_SG
NUM_SP
NUM_S
NUM_TH
NUM_V
NUM_b
NUM_c
NUM_d
NUM_e
NUM_fm
NUM_g
NUM_l
NUM_mi
NUM_pl
NUM_pr
NUM_rn
NUM_sg
NUM_sp
NUM_s
NUM_th
NUM_v
_NUM_last_

Definition at line 759 of file formatting.c.

{
    NUM_COMMA,
    NUM_DEC,
    NUM_0,
    NUM_9,
    NUM_B,
    NUM_C,
    NUM_D,
    NUM_E,
    NUM_FM,
    NUM_G,
    NUM_L,
    NUM_MI,
    NUM_PL,
    NUM_PR,
    NUM_RN,
    NUM_SG,
    NUM_SP,
    NUM_S,
    NUM_TH,
    NUM_V,
    NUM_b,
    NUM_c,
    NUM_d,
    NUM_e,
    NUM_fm,
    NUM_g,
    NUM_l,
    NUM_mi,
    NUM_pl,
    NUM_pr,
    NUM_rn,
    NUM_sg,
    NUM_sp,
    NUM_s,
    NUM_th,
    NUM_v,
 
    /* last */
    _NUM_last_
}           NUM_poz;

NUMDesc_lsign

enum NUMDesc_lsign

Enumerator
NUM_LSIGN_PRE
NUM_LSIGN_POST
NUM_LSIGN_NONE

Definition at line 295 of file formatting.c.

{
    NUM_LSIGN_PRE = -1,
    NUM_LSIGN_POST = 1,
    NUM_LSIGN_NONE = 0,
};

TH_Case

enum TH_Case

Enumerator
TH_UPPER
TH_LOWER

Definition at line 289 of file formatting.c.

{
    TH_UPPER = 1,
    TH_LOWER = 2,
};

Function Documentation

adjust_partial_year_to_2020()

static int adjust_partial_year_to_2020 ( int  year )

static

Definition at line 2069 of file formatting.c.

{
    /*
     * Adjust all dates toward 2020; this is effectively what happens when we
     * assume '70' is 1970 and '69' is 2069.
     */
    /* Force 0-69 into the 2000's */
    if (year < 70)
        return year + 2000;
    /* Force 70-99 into the 1900's */
    else if (year < 100)
        return year + 1900;
    /* Force 100-519 into the 2000's */
    else if (year < 520)
        return year + 2000;
    /* Force 520-999 into the 1000's */
    else if (year < 1000)
        return year + 1000;
    else
        return year;
}

Referenced by DCH_from_char().

asc_initcap()

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

Definition at line 1924 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 1880 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_tolower_z()

static char * asc_tolower_z ( const char *  buff )

static

Definition at line 1972 of file formatting.c.

{
    return asc_tolower(buff, strlen(buff));
}

References asc_tolower().

Referenced by DCH_to_char(), and NUM_processor().

asc_toupper()

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

Definition at line 1902 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().

asc_toupper_z()

static char * asc_toupper_z ( const char *  buff )

static

Definition at line 1978 of file formatting.c.

{
    return asc_toupper(buff, strlen(buff));
}

References asc_toupper().

Referenced by DCH_to_char().

datetime_format_has_tz()

bool datetime_format_has_tz

(

const char *

fmt_str

)

Definition at line 4317 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().

datetime_to_char_body()

static text * datetime_to_char_body ( TmToChar *  tmtc, const text *  fmt, bool  is_interval, Oid  collid  )

static

Definition at line 3888 of file formatting.c.

{
    FormatNode *format;
    char       *fmt_str,
               *result;
    bool        incache;
    size_t      fmt_len;
    text       *res;
 
    /*
     * Convert fmt to C string
     */
    fmt_str = text_to_cstring(fmt);
    fmt_len = strlen(fmt_str);
 
    /*
     * Allocate workspace for result as C string
     */
    result = palloc((fmt_len * DCH_MAX_ITEM_SIZ) + 1);
    *result = '\0';
 
    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;
    }
 
    /* The real work is here */
    DCH_to_char(format, is_interval, tmtc, result, collid);
 
    if (!incache)
        pfree(format);
 
    pfree(fmt_str);
 
    /* convert C-string result to TEXT format */
    res = cstring_to_text(result);
 
    pfree(result);
    return res;
}

References collid, cstring_to_text(), DCH_cache_fetch(), DCH_CACHE_SIZE, DCH_FLAG, DCH_index, DCH_keywords, DCH_MAX_ITEM_SIZ, DCH_suff, DCH_to_char(), DCHCacheEntry::format, format, palloc(), parse_format(), pfree(), and text_to_cstring().

Referenced by interval_to_char(), timestamp_to_char(), and timestamptz_to_char().

DCH_cache_fetch()

static DCHCacheEntry * DCH_cache_fetch ( const char *  str, bool  std  )

static

Definition at line 3861 of file formatting.c.

{
    DCHCacheEntry *ent;
 
    if ((ent = DCH_cache_search(str, std)) == NULL)
    {
        /*
         * Not in the cache, must run parser and save a new format-picture to
         * the cache.  Do not mark the cache entry valid until parsing
         * succeeds.
         */
        ent = DCH_cache_getnew(str, std);
 
        parse_format(ent->format, str, DCH_keywords, DCH_suff, DCH_index,
                     DCH_FLAG | (std ? STD_FLAG : 0), NULL);
 
        ent->valid = true;
    }
    return ent;
}

References DCH_cache_getnew(), DCH_cache_search(), DCH_FLAG, DCH_index, DCH_keywords, DCH_suff, DCHCacheEntry::format, parse_format(), STD_FLAG, str, and DCHCacheEntry::valid.

Referenced by datetime_format_has_tz(), datetime_to_char_body(), and do_to_timestamp().

DCH_cache_getnew()

static DCHCacheEntry * DCH_cache_getnew ( const char *  str, bool  std  )

static

Definition at line 3780 of file formatting.c.

{
    DCHCacheEntry *ent;
 
    /* Ensure we can advance DCHCounter below */
    DCH_prevent_counter_overflow();
 
    /*
     * If cache is full, remove oldest entry (or recycle first not-valid one)
     */
    if (n_DCHCache >= DCH_CACHE_ENTRIES)
    {
        DCHCacheEntry *old = DCHCache[0];
 
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "cache is full (%d)", n_DCHCache);
#endif
        if (old->valid)
        {
            for (int i = 1; i < DCH_CACHE_ENTRIES; i++)
            {
                ent = DCHCache[i];
                if (!ent->valid)
                {
                    old = ent;
                    break;
                }
                if (ent->age < old->age)
                    old = ent;
            }
        }
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "OLD: '%s' AGE: %d", old->str, old->age);
#endif
        old->valid = false;
        strlcpy(old->str, str, DCH_CACHE_SIZE + 1);
        old->age = (++DCHCounter);
        /* caller is expected to fill format, then set valid */
        return old;
    }
    else
    {
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "NEW (%d)", n_DCHCache);
#endif
        Assert(DCHCache[n_DCHCache] == NULL);
        DCHCache[n_DCHCache] = ent = (DCHCacheEntry *)
            MemoryContextAllocZero(TopMemoryContext, sizeof(DCHCacheEntry));
        ent->valid = false;
        strlcpy(ent->str, str, DCH_CACHE_SIZE + 1);
        ent->std = std;
        ent->age = (++DCHCounter);
        /* caller is expected to fill format, then set valid */
        ++n_DCHCache;
        return ent;
    }
}

References DCHCacheEntry::age, Assert(), DCH_CACHE_ENTRIES, DCH_CACHE_SIZE, DCH_prevent_counter_overflow(), DCHCache, DCHCounter, elog, i, MemoryContextAllocZero(), n_DCHCache, DCHCacheEntry::std, DCHCacheEntry::str, str, strlcpy(), TopMemoryContext, and DCHCacheEntry::valid.

Referenced by DCH_cache_fetch().

DCH_cache_search()

static DCHCacheEntry * DCH_cache_search ( const char *  str, bool  std  )

static

Definition at line 3840 of file formatting.c.

{
    /* Ensure we can advance DCHCounter below */
    DCH_prevent_counter_overflow();
 
    for (int i = 0; i < n_DCHCache; i++)
    {
        DCHCacheEntry *ent = DCHCache[i];
 
        if (ent->valid && strcmp(ent->str, str) == 0 && ent->std == std)
        {
            ent->age = (++DCHCounter);
            return ent;
        }
    }
 
    return NULL;
}

References DCHCacheEntry::age, DCH_prevent_counter_overflow(), DCHCache, DCHCounter, i, n_DCHCache, DCHCacheEntry::std, DCHCacheEntry::str, str, and DCHCacheEntry::valid.

Referenced by DCH_cache_fetch().

DCH_datetime_type()

static int DCH_datetime_type ( FormatNode *  node )

static

Definition at line 3684 of file formatting.c.

{
    int         flags = 0;
 
    for (FormatNode *n = node; n->type != NODE_TYPE_END; n++)
    {
        if (n->type != NODE_TYPE_ACTION)
            continue;
 
        switch (n->key->id)
        {
            case DCH_FX:
                break;
            case DCH_A_M:
            case DCH_P_M:
            case DCH_a_m:
            case DCH_p_m:
            case DCH_AM:
            case DCH_PM:
            case DCH_am:
            case DCH_pm:
            case DCH_HH:
            case DCH_HH12:
            case DCH_HH24:
            case DCH_MI:
            case DCH_SS:
            case DCH_MS:        /* millisecond */
            case DCH_US:        /* microsecond */
            case DCH_FF1:
            case DCH_FF2:
            case DCH_FF3:
            case DCH_FF4:
            case DCH_FF5:
            case DCH_FF6:
            case DCH_SSSS:
                flags |= DCH_TIMED;
                break;
            case DCH_tz:
            case DCH_TZ:
            case DCH_OF:
            case DCH_TZH:
            case DCH_TZM:
                flags |= DCH_ZONED;
                break;
            case DCH_A_D:
            case DCH_B_C:
            case DCH_a_d:
            case DCH_b_c:
            case DCH_AD:
            case DCH_BC:
            case DCH_ad:
            case DCH_bc:
            case DCH_MONTH:
            case DCH_Month:
            case DCH_month:
            case DCH_MON:
            case DCH_Mon:
            case DCH_mon:
            case DCH_MM:
            case DCH_DAY:
            case DCH_Day:
            case DCH_day:
            case DCH_DY:
            case DCH_Dy:
            case DCH_dy:
            case DCH_DDD:
            case DCH_IDDD:
            case DCH_DD:
            case DCH_D:
            case DCH_ID:
            case DCH_WW:
            case DCH_Q:
            case DCH_CC:
            case DCH_Y_YYY:
            case DCH_YYYY:
            case DCH_IYYY:
            case DCH_YYY:
            case DCH_IYY:
            case DCH_YY:
            case DCH_IY:
            case DCH_Y:
            case DCH_I:
            case DCH_RM:
            case DCH_rm:
            case DCH_W:
            case DCH_J:
                flags |= DCH_DATED;
                break;
        }
    }
 
    return flags;
}

References DCH_A_D, DCH_a_d, DCH_A_M, DCH_a_m, DCH_AD, DCH_ad, DCH_AM, DCH_am, DCH_B_C, DCH_b_c, DCH_BC, DCH_bc, DCH_CC, DCH_D, DCH_DATED, DCH_DAY, DCH_Day, DCH_day, DCH_DD, DCH_DDD, DCH_DY, DCH_Dy, DCH_dy, DCH_FF1, DCH_FF2, DCH_FF3, DCH_FF4, DCH_FF5, DCH_FF6, DCH_FX, DCH_HH, DCH_HH12, DCH_HH24, DCH_I, DCH_ID, DCH_IDDD, DCH_IY, DCH_IYY, DCH_IYYY, DCH_J, DCH_MI, DCH_MM, DCH_MON, DCH_Mon, DCH_mon, DCH_MONTH, DCH_Month, DCH_month, DCH_MS, DCH_OF, DCH_P_M, DCH_p_m, DCH_PM, DCH_pm, DCH_Q, DCH_RM, DCH_rm, DCH_SS, DCH_SSSS, DCH_TIMED, DCH_TZ, DCH_tz, DCH_TZH, DCH_TZM, DCH_US, DCH_W, DCH_WW, DCH_Y, DCH_Y_YYY, DCH_YY, DCH_YYY, DCH_YYYY, DCH_ZONED, KeyWord::id, FormatNode::key, NODE_TYPE_ACTION, NODE_TYPE_END, and FormatNode::type.

Referenced by datetime_format_has_tz(), and do_to_timestamp().

DCH_from_char()

static void DCH_from_char ( FormatNode *  node, const char *  in, TmFromChar *  out, Oid  collid, bool  std, Node *  escontext  )

static

Definition at line 3114 of file formatting.c.

{
    FormatNode *n;
    const char *s;
    int         len,
                value;
    bool        fx_mode = std;
 
    /* number of extra skipped characters (more than given in format string) */
    int         extra_skip = 0;
 
    /* cache localized days and months */
    cache_locale_time();
 
    for (n = node, s = in; n->type != NODE_TYPE_END && *s != '\0'; n++)
    {
        /*
         * Ignore spaces at the beginning of the string and before fields when
         * not in FX (fixed width) mode.
         */
        if (!fx_mode && (n->type != NODE_TYPE_ACTION || n->key->id != DCH_FX) &&
            (n->type == NODE_TYPE_ACTION || n == node))
        {
            while (*s != '\0' && isspace((unsigned char) *s))
            {
                s++;
                extra_skip++;
            }
        }
 
        if (n->type == NODE_TYPE_SPACE || n->type == NODE_TYPE_SEPARATOR)
        {
            if (std)
            {
                /*
                 * Standard mode requires strict matching between format
                 * string separators/spaces and input string.
                 */
                Assert(n->character[0] && !n->character[1]);
 
                if (*s == n->character[0])
                    s++;
                else
                    ereturn(escontext,,
                            (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                             errmsg("unmatched format separator \"%c\"",
                                    n->character[0])));
            }
            else if (!fx_mode)
            {
                /*
                 * In non FX (fixed format) mode one format string space or
                 * separator match to one space or separator in input string.
                 * Or match nothing if there is no space or separator in the
                 * current position of input string.
                 */
                extra_skip--;
                if (isspace((unsigned char) *s) || is_separator_char(s))
                {
                    s++;
                    extra_skip++;
                }
            }
            else
            {
                /*
                 * In FX mode, on format string space or separator we consume
                 * exactly one character from input string.  Notice we don't
                 * insist that the consumed character match the format's
                 * character.
                 */
                s += pg_mblen(s);
            }
            continue;
        }
        else if (n->type != NODE_TYPE_ACTION)
        {
            /*
             * Text character, so consume one character from input string.
             * Notice we don't insist that the consumed character match the
             * format's character.
             */
            if (!fx_mode)
            {
                /*
                 * In non FX mode we might have skipped some extra characters
                 * (more than specified in format string) before.  In this
                 * case we don't skip input string character, because it might
                 * be part of field.
                 */
                if (extra_skip > 0)
                    extra_skip--;
                else
                    s += pg_mblen(s);
            }
            else
            {
                int         chlen = pg_mblen(s);
 
                /*
                 * Standard mode requires strict match of format characters.
                 */
                if (std && n->type == NODE_TYPE_CHAR &&
                    strncmp(s, n->character, chlen) != 0)
                    ereturn(escontext,,
                            (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                             errmsg("unmatched format character \"%s\"",
                                    n->character)));
 
                s += chlen;
            }
            continue;
        }
 
        if (!from_char_set_mode(out, n->key->date_mode, escontext))
            return;
 
        switch (n->key->id)
        {
            case DCH_FX:
                fx_mode = true;
                break;
            case DCH_A_M:
            case DCH_P_M:
            case DCH_a_m:
            case DCH_p_m:
                if (!from_char_seq_search(&value, &s, ampm_strings_long,
                                          NULL, InvalidOid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->pm, value % 2, n, escontext))
                    return;
                out->clock_12_hour = true;
                break;
            case DCH_AM:
            case DCH_PM:
            case DCH_am:
            case DCH_pm:
                if (!from_char_seq_search(&value, &s, ampm_strings,
                                          NULL, InvalidOid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->pm, value % 2, n, escontext))
                    return;
                out->clock_12_hour = true;
                break;
            case DCH_HH:
            case DCH_HH12:
                if (from_char_parse_int_len(&out->hh, &s, 2, n, escontext) < 0)
                    return;
                out->clock_12_hour = true;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_HH24:
                if (from_char_parse_int_len(&out->hh, &s, 2, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_MI:
                if (from_char_parse_int(&out->mi, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_SS:
                if (from_char_parse_int(&out->ss, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_MS:        /* millisecond */
                len = from_char_parse_int_len(&out->ms, &s, 3, n, escontext);
                if (len < 0)
                    return;
 
                /*
                 * 25 is 0.25 and 250 is 0.25 too; 025 is 0.025 and not 0.25
                 */
                out->ms *= len == 1 ? 100 :
                    len == 2 ? 10 : 1;
 
                SKIP_THth(s, n->suffix);
                break;
            case DCH_FF1:
            case DCH_FF2:
            case DCH_FF3:
            case DCH_FF4:
            case DCH_FF5:
            case DCH_FF6:
                out->ff = n->key->id - DCH_FF1 + 1;
                /* FALLTHROUGH */
            case DCH_US:        /* microsecond */
                len = from_char_parse_int_len(&out->us, &s,
                                              n->key->id == DCH_US ? 6 :
                                              out->ff, n, escontext);
                if (len < 0)
                    return;
 
                out->us *= len == 1 ? 100000 :
                    len == 2 ? 10000 :
                    len == 3 ? 1000 :
                    len == 4 ? 100 :
                    len == 5 ? 10 : 1;
 
                SKIP_THth(s, n->suffix);
                break;
            case DCH_SSSS:
                if (from_char_parse_int(&out->ssss, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_tz:
            case DCH_TZ:
                {
                    int         tzlen;
 
                    tzlen = DecodeTimezoneAbbrevPrefix(s,
                                                       &out->gmtoffset,
                                                       &out->tzp);
                    if (tzlen > 0)
                    {
                        out->has_tz = true;
                        /* we only need the zone abbrev for DYNTZ case */
                        if (out->tzp)
                            out->abbrev = pnstrdup(s, tzlen);
                        out->tzsign = 0;    /* drop any earlier TZH/TZM info */
                        s += tzlen;
                        break;
                    }
                    else if (isalpha((unsigned char) *s))
                    {
                        /*
                         * It doesn't match any abbreviation, but it starts
                         * with a letter.  OF format certainly won't succeed;
                         * assume it's a misspelled abbreviation and complain
                         * accordingly.
                         */
                        ereturn(escontext,,
                                (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                                 errmsg("invalid value \"%s\" for \"%s\"", s, n->key->name),
                                 errdetail("Time zone abbreviation is not recognized.")));
                    }
                    /* otherwise parse it like OF */
                }
                /* FALLTHROUGH */
            case DCH_OF:
                /* OF is equivalent to TZH or TZH:TZM */
                /* see TZH comments below */
                if (*s == '+' || *s == '-' || *s == ' ')
                {
                    out->tzsign = *s == '-' ? -1 : +1;
                    s++;
                }
                else
                {
                    if (extra_skip > 0 && *(s - 1) == '-')
                        out->tzsign = -1;
                    else
                        out->tzsign = +1;
                }
                if (from_char_parse_int_len(&out->tzh, &s, 2, n, escontext) < 0)
                    return;
                if (*s == ':')
                {
                    s++;
                    if (from_char_parse_int_len(&out->tzm, &s, 2, n,
                                                escontext) < 0)
                        return;
                }
                break;
            case DCH_TZH:
 
                /*
                 * Value of TZH might be negative.  And the issue is that we
                 * might swallow minus sign as the separator.  So, if we have
                 * skipped more characters than specified in the format
                 * string, then we consider prepending last skipped minus to
                 * TZH.
                 */
                if (*s == '+' || *s == '-' || *s == ' ')
                {
                    out->tzsign = *s == '-' ? -1 : +1;
                    s++;
                }
                else
                {
                    if (extra_skip > 0 && *(s - 1) == '-')
                        out->tzsign = -1;
                    else
                        out->tzsign = +1;
                }
 
                if (from_char_parse_int_len(&out->tzh, &s, 2, n, escontext) < 0)
                    return;
                break;
            case DCH_TZM:
                /* assign positive timezone sign if TZH was not seen before */
                if (!out->tzsign)
                    out->tzsign = +1;
                if (from_char_parse_int_len(&out->tzm, &s, 2, n, escontext) < 0)
                    return;
                break;
            case DCH_A_D:
            case DCH_B_C:
            case DCH_a_d:
            case DCH_b_c:
                if (!from_char_seq_search(&value, &s, adbc_strings_long,
                                          NULL, InvalidOid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->bc, value % 2, n, escontext))
                    return;
                break;
            case DCH_AD:
            case DCH_BC:
            case DCH_ad:
            case DCH_bc:
                if (!from_char_seq_search(&value, &s, adbc_strings,
                                          NULL, InvalidOid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->bc, value % 2, n, escontext))
                    return;
                break;
            case DCH_MONTH:
            case DCH_Month:
            case DCH_month:
                if (!from_char_seq_search(&value, &s, months_full,
                                          IS_SUFFIX_TM(n->suffix) ? localized_full_months : NULL,
                                          collid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->mm, value + 1, n, escontext))
                    return;
                break;
            case DCH_MON:
            case DCH_Mon:
            case DCH_mon:
                if (!from_char_seq_search(&value, &s, months,
                                          IS_SUFFIX_TM(n->suffix) ? localized_abbrev_months : NULL,
                                          collid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->mm, value + 1, n, escontext))
                    return;
                break;
            case DCH_MM:
                if (from_char_parse_int(&out->mm, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_DAY:
            case DCH_Day:
            case DCH_day:
                if (!from_char_seq_search(&value, &s, days,
                                          IS_SUFFIX_TM(n->suffix) ? localized_full_days : NULL,
                                          collid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->d, value, n, escontext))
                    return;
                out->d++;
                break;
            case DCH_DY:
            case DCH_Dy:
            case DCH_dy:
                if (!from_char_seq_search(&value, &s, days_short,
                                          IS_SUFFIX_TM(n->suffix) ? localized_abbrev_days : NULL,
                                          collid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->d, value, n, escontext))
                    return;
                out->d++;
                break;
            case DCH_DDD:
                if (from_char_parse_int(&out->ddd, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_IDDD:
                if (from_char_parse_int_len(&out->ddd, &s, 3, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_DD:
                if (from_char_parse_int(&out->dd, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_D:
                if (from_char_parse_int(&out->d, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_ID:
                if (from_char_parse_int_len(&out->d, &s, 1, n, escontext) < 0)
                    return;
                /* Shift numbering to match Gregorian where Sunday = 1 */
                if (++out->d > 7)
                    out->d = 1;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_WW:
            case DCH_IW:
                if (from_char_parse_int(&out->ww, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_Q:
 
                /*
                 * We ignore 'Q' when converting to date because it is unclear
                 * which date in the quarter to use, and some people specify
                 * both quarter and month, so if it was honored it might
                 * conflict with the supplied month. That is also why we don't
                 * throw an error.
                 *
                 * We still parse the source string for an integer, but it
                 * isn't stored anywhere in 'out'.
                 */
                if (from_char_parse_int((int *) NULL, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_CC:
                if (from_char_parse_int(&out->cc, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_Y_YYY:
                {
                    int         matched,
                                years,
                                millennia,
                                nch;
 
                    matched = sscanf(s, "%d,%03d%n", &millennia, &years, &nch);
                    if (matched < 2)
                        ereturn(escontext,,
                                (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                                 errmsg("invalid value \"%s\" for \"%s\"", s, "Y,YYY")));
 
                    /* years += (millennia * 1000); */
                    if (pg_mul_s32_overflow(millennia, 1000, &millennia) ||
                        pg_add_s32_overflow(years, millennia, &years))
                        ereturn(escontext,,
                                (errcode(ERRCODE_DATETIME_FIELD_OVERFLOW),
                                 errmsg("value for \"%s\" in source string is out of range", "Y,YYY")));
 
                    if (!from_char_set_int(&out->year, years, n, escontext))
                        return;
                    out->yysz = 4;
                    s += nch;
                    SKIP_THth(s, n->suffix);
                }
                break;
            case DCH_YYYY:
            case DCH_IYYY:
                if (from_char_parse_int(&out->year, &s, n, escontext) < 0)
                    return;
                out->yysz = 4;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_YYY:
            case DCH_IYY:
                len = from_char_parse_int(&out->year, &s, n, escontext);
                if (len < 0)
                    return;
                if (len < 4)
                    out->year = adjust_partial_year_to_2020(out->year);
                out->yysz = 3;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_YY:
            case DCH_IY:
                len = from_char_parse_int(&out->year, &s, n, escontext);
                if (len < 0)
                    return;
                if (len < 4)
                    out->year = adjust_partial_year_to_2020(out->year);
                out->yysz = 2;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_Y:
            case DCH_I:
                len = from_char_parse_int(&out->year, &s, n, escontext);
                if (len < 0)
                    return;
                if (len < 4)
                    out->year = adjust_partial_year_to_2020(out->year);
                out->yysz = 1;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_RM:
            case DCH_rm:
                if (!from_char_seq_search(&value, &s, rm_months_lower,
                                          NULL, InvalidOid,
                                          n, escontext))
                    return;
                if (!from_char_set_int(&out->mm, MONTHS_PER_YEAR - value, n,
                                       escontext))
                    return;
                break;
            case DCH_W:
                if (from_char_parse_int(&out->w, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
            case DCH_J:
                if (from_char_parse_int(&out->j, &s, n, escontext) < 0)
                    return;
                SKIP_THth(s, n->suffix);
                break;
        }
 
        /* Ignore all spaces after fields */
        if (!fx_mode)
        {
            extra_skip = 0;
            while (*s != '\0' && isspace((unsigned char) *s))
            {
                s++;
                extra_skip++;
            }
        }
    }
 
    /*
     * Standard parsing mode doesn't allow unmatched format patterns or
     * trailing characters in the input string.
     */
    if (std)
    {
        if (n->type != NODE_TYPE_END)
            ereturn(escontext,,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("input string is too short for datetime format")));
 
        while (*s != '\0' && isspace((unsigned char) *s))
            s++;
 
        if (*s != '\0')
            ereturn(escontext,,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("trailing characters remain in input string after datetime format")));
    }
}

References TmFromChar::abbrev, adbc_strings, adbc_strings_long, adjust_partial_year_to_2020(), ampm_strings, ampm_strings_long, Assert(), TmFromChar::bc, cache_locale_time(), TmFromChar::cc, FormatNode::character, TmFromChar::clock_12_hour, collid, TmFromChar::d, KeyWord::date_mode, days, days_short, DCH_A_D, DCH_a_d, DCH_A_M, DCH_a_m, DCH_AD, DCH_ad, DCH_AM, DCH_am, DCH_B_C, DCH_b_c, DCH_BC, DCH_bc, DCH_CC, DCH_D, DCH_DAY, DCH_Day, DCH_day, DCH_DD, DCH_DDD, DCH_DY, DCH_Dy, DCH_dy, DCH_FF1, DCH_FF2, DCH_FF3, DCH_FF4, DCH_FF5, DCH_FF6, DCH_FX, DCH_HH, DCH_HH12, DCH_HH24, DCH_I, DCH_ID, DCH_IDDD, DCH_IW, DCH_IY, DCH_IYY, DCH_IYYY, DCH_J, DCH_MI, DCH_MM, DCH_MON, DCH_Mon, DCH_mon, DCH_MONTH, DCH_Month, DCH_month, DCH_MS, DCH_OF, DCH_P_M, DCH_p_m, DCH_PM, DCH_pm, DCH_Q, DCH_RM, DCH_rm, DCH_SS, DCH_SSSS, DCH_TZ, DCH_tz, DCH_TZH, DCH_TZM, DCH_US, DCH_W, DCH_WW, DCH_Y, DCH_Y_YYY, DCH_YY, DCH_YYY, DCH_YYYY, TmFromChar::dd, TmFromChar::ddd, DecodeTimezoneAbbrevPrefix(), ereturn, errcode(), errdetail(), errmsg(), TmFromChar::ff, from_char_parse_int(), from_char_parse_int_len(), from_char_seq_search(), from_char_set_int(), from_char_set_mode(), TmFromChar::gmtoffset, TmFromChar::has_tz, TmFromChar::hh, KeyWord::id, InvalidOid, is_separator_char(), IS_SUFFIX_TM(), TmFromChar::j, FormatNode::key, len, localized_abbrev_days, localized_abbrev_months, localized_full_days, localized_full_months, TmFromChar::mi, TmFromChar::mm, months, months_full, MONTHS_PER_YEAR, TmFromChar::ms, KeyWord::name, NODE_TYPE_ACTION, NODE_TYPE_CHAR, NODE_TYPE_END, NODE_TYPE_SEPARATOR, NODE_TYPE_SPACE, pg_add_s32_overflow(), pg_mblen(), pg_mul_s32_overflow(), TmFromChar::pm, pnstrdup(), rm_months_lower, SKIP_THth, TmFromChar::ss, TmFromChar::ssss, FormatNode::suffix, FormatNode::type, TmFromChar::tzh, TmFromChar::tzm, TmFromChar::tzp, TmFromChar::tzsign, TmFromChar::us, value, TmFromChar::w, TmFromChar::ww, TmFromChar::year, and TmFromChar::yysz.

Referenced by do_to_timestamp().

DCH_prevent_counter_overflow()

static void DCH_prevent_counter_overflow ( void  )

inlinestatic

Definition at line 3670 of file formatting.c.

{
    if (DCHCounter >= (INT_MAX - 1))
    {
        for (int i = 0; i < n_DCHCache; i++)
            DCHCache[i]->age >>= 1;
        DCHCounter >>= 1;
    }
}

References DCHCache, DCHCounter, i, and n_DCHCache.

Referenced by DCH_cache_getnew(), and DCH_cache_search().

DCH_to_char()

static void DCH_to_char ( FormatNode *  node, bool  is_interval, TmToChar *  in, char *  out, Oid  collid  )

static

Definition at line 2468 of file formatting.c.

{
    char       *s;
    struct fmt_tm *tm = &in->tm;
    int         i;
 
    /* cache localized days and months */
    cache_locale_time();
 
    s = out;
    for (FormatNode *n = node; n->type != NODE_TYPE_END; n++)
    {
        if (n->type != NODE_TYPE_ACTION)
        {
            strcpy(s, n->character);
            s += strlen(s);
            continue;
        }
 
        switch (n->key->id)
        {
            case DCH_A_M:
            case DCH_P_M:
                strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                       ? P_M_STR : A_M_STR);
                s += strlen(s);
                break;
            case DCH_AM:
            case DCH_PM:
                strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                       ? PM_STR : AM_STR);
                s += strlen(s);
                break;
            case DCH_a_m:
            case DCH_p_m:
                strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                       ? p_m_STR : a_m_STR);
                s += strlen(s);
                break;
            case DCH_am:
            case DCH_pm:
                strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                       ? pm_STR : am_STR);
                s += strlen(s);
                break;
            case DCH_HH:
            case DCH_HH12:
 
                /*
                 * display time as shown on a 12-hour clock, even for
                 * intervals
                 */
                sprintf(s, "%0*lld", IS_SUFFIX_FM(n->suffix) ? 0 : (tm->tm_hour >= 0) ? 2 : 3,
                        tm->tm_hour % (HOURS_PER_DAY / 2) == 0 ?
                        (long long) (HOURS_PER_DAY / 2) :
                        (long long) (tm->tm_hour % (HOURS_PER_DAY / 2)));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_HH24:
                sprintf(s, "%0*lld", IS_SUFFIX_FM(n->suffix) ? 0 : (tm->tm_hour >= 0) ? 2 : 3,
                        (long long) tm->tm_hour);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_MI:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : (tm->tm_min >= 0) ? 2 : 3,
                        tm->tm_min);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_SS:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : (tm->tm_sec >= 0) ? 2 : 3,
                        tm->tm_sec);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
 
#define DCH_to_char_fsec(frac_fmt, frac_val) \
                sprintf(s, frac_fmt, (int) (frac_val)); \
                if (IS_SUFFIX_THth(n->suffix)) \
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix)); \
                s += strlen(s)
 
            case DCH_FF1:       /* tenth of second */
                DCH_to_char_fsec("%01d", in->fsec / 100000);
                break;
            case DCH_FF2:       /* hundredth of second */
                DCH_to_char_fsec("%02d", in->fsec / 10000);
                break;
            case DCH_FF3:
            case DCH_MS:        /* millisecond */
                DCH_to_char_fsec("%03d", in->fsec / 1000);
                break;
            case DCH_FF4:       /* tenth of a millisecond */
                DCH_to_char_fsec("%04d", in->fsec / 100);
                break;
            case DCH_FF5:       /* hundredth of a millisecond */
                DCH_to_char_fsec("%05d", in->fsec / 10);
                break;
            case DCH_FF6:
            case DCH_US:        /* microsecond */
                DCH_to_char_fsec("%06d", in->fsec);
                break;
#undef DCH_to_char_fsec
            case DCH_SSSS:
                sprintf(s, "%lld",
                        (long long) (tm->tm_hour * SECS_PER_HOUR +
                                     tm->tm_min * SECS_PER_MINUTE +
                                     tm->tm_sec));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_tz:
                INVALID_FOR_INTERVAL;
                if (tmtcTzn(in))
                {
                    /* We assume here that timezone names aren't localized */
                    char       *p = asc_tolower_z(tmtcTzn(in));
 
                    strcpy(s, p);
                    pfree(p);
                    s += strlen(s);
                }
                break;
            case DCH_TZ:
                INVALID_FOR_INTERVAL;
                if (tmtcTzn(in))
                {
                    strcpy(s, tmtcTzn(in));
                    s += strlen(s);
                }
                break;
            case DCH_TZH:
                INVALID_FOR_INTERVAL;
                sprintf(s, "%c%02d",
                        (tm->tm_gmtoff >= 0) ? '+' : '-',
                        abs((int) tm->tm_gmtoff) / SECS_PER_HOUR);
                s += strlen(s);
                break;
            case DCH_TZM:
                INVALID_FOR_INTERVAL;
                sprintf(s, "%02d",
                        (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR) / SECS_PER_MINUTE);
                s += strlen(s);
                break;
            case DCH_OF:
                INVALID_FOR_INTERVAL;
                sprintf(s, "%c%0*d",
                        (tm->tm_gmtoff >= 0) ? '+' : '-',
                        IS_SUFFIX_FM(n->suffix) ? 0 : 2,
                        abs((int) tm->tm_gmtoff) / SECS_PER_HOUR);
                s += strlen(s);
                if (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR != 0)
                {
                    sprintf(s, ":%02d",
                            (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR) / SECS_PER_MINUTE);
                    s += strlen(s);
                }
                break;
            case DCH_A_D:
            case DCH_B_C:
                INVALID_FOR_INTERVAL;
                strcpy(s, (tm->tm_year <= 0 ? B_C_STR : A_D_STR));
                s += strlen(s);
                break;
            case DCH_AD:
            case DCH_BC:
                INVALID_FOR_INTERVAL;
                strcpy(s, (tm->tm_year <= 0 ? BC_STR : AD_STR));
                s += strlen(s);
                break;
            case DCH_a_d:
            case DCH_b_c:
                INVALID_FOR_INTERVAL;
                strcpy(s, (tm->tm_year <= 0 ? b_c_STR : a_d_STR));
                s += strlen(s);
                break;
            case DCH_ad:
            case DCH_bc:
                INVALID_FOR_INTERVAL;
                strcpy(s, (tm->tm_year <= 0 ? bc_STR : ad_STR));
                s += strlen(s);
                break;
            case DCH_MONTH:
                INVALID_FOR_INTERVAL;
                if (!tm->tm_mon)
                    break;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_toupper_z(localized_full_months[tm->tm_mon - 1], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -9,
                            asc_toupper_z(months_full[tm->tm_mon - 1]));
                s += strlen(s);
                break;
            case DCH_Month:
                INVALID_FOR_INTERVAL;
                if (!tm->tm_mon)
                    break;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_initcap_z(localized_full_months[tm->tm_mon - 1], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -9,
                            months_full[tm->tm_mon - 1]);
                s += strlen(s);
                break;
            case DCH_month:
                INVALID_FOR_INTERVAL;
                if (!tm->tm_mon)
                    break;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_tolower_z(localized_full_months[tm->tm_mon - 1], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -9,
                            asc_tolower_z(months_full[tm->tm_mon - 1]));
                s += strlen(s);
                break;
            case DCH_MON:
                INVALID_FOR_INTERVAL;
                if (!tm->tm_mon)
                    break;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_toupper_z(localized_abbrev_months[tm->tm_mon - 1], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    strcpy(s, asc_toupper_z(months[tm->tm_mon - 1]));
                s += strlen(s);
                break;
            case DCH_Mon:
                INVALID_FOR_INTERVAL;
                if (!tm->tm_mon)
                    break;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_initcap_z(localized_abbrev_months[tm->tm_mon - 1], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    strcpy(s, months[tm->tm_mon - 1]);
                s += strlen(s);
                break;
            case DCH_mon:
                INVALID_FOR_INTERVAL;
                if (!tm->tm_mon)
                    break;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_tolower_z(localized_abbrev_months[tm->tm_mon - 1], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    strcpy(s, asc_tolower_z(months[tm->tm_mon - 1]));
                s += strlen(s);
                break;
            case DCH_MM:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : (tm->tm_mon >= 0) ? 2 : 3,
                        tm->tm_mon);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_DAY:
                INVALID_FOR_INTERVAL;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_toupper_z(localized_full_days[tm->tm_wday], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -9,
                            asc_toupper_z(days[tm->tm_wday]));
                s += strlen(s);
                break;
            case DCH_Day:
                INVALID_FOR_INTERVAL;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_initcap_z(localized_full_days[tm->tm_wday], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -9,
                            days[tm->tm_wday]);
                s += strlen(s);
                break;
            case DCH_day:
                INVALID_FOR_INTERVAL;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_tolower_z(localized_full_days[tm->tm_wday], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -9,
                            asc_tolower_z(days[tm->tm_wday]));
                s += strlen(s);
                break;
            case DCH_DY:
                INVALID_FOR_INTERVAL;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_toupper_z(localized_abbrev_days[tm->tm_wday], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    strcpy(s, asc_toupper_z(days_short[tm->tm_wday]));
                s += strlen(s);
                break;
            case DCH_Dy:
                INVALID_FOR_INTERVAL;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_initcap_z(localized_abbrev_days[tm->tm_wday], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    strcpy(s, days_short[tm->tm_wday]);
                s += strlen(s);
                break;
            case DCH_dy:
                INVALID_FOR_INTERVAL;
                if (IS_SUFFIX_TM(n->suffix))
                {
                    char       *str = str_tolower_z(localized_abbrev_days[tm->tm_wday], collid);
 
                    if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                        strcpy(s, str);
                    else
                        ereport(ERROR,
                                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                 errmsg("localized string format value too long")));
                }
                else
                    strcpy(s, asc_tolower_z(days_short[tm->tm_wday]));
                s += strlen(s);
                break;
            case DCH_DDD:
            case DCH_IDDD:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : 3,
                        (n->key->id == DCH_DDD) ?
                        tm->tm_yday :
                        date2isoyearday(tm->tm_year, tm->tm_mon, tm->tm_mday));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_DD:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : 2, tm->tm_mday);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_D:
                INVALID_FOR_INTERVAL;
                sprintf(s, "%d", tm->tm_wday + 1);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_ID:
                INVALID_FOR_INTERVAL;
                sprintf(s, "%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_WW:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : 2,
                        (tm->tm_yday - 1) / 7 + 1);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_IW:
                sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : 2,
                        date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_Q:
                if (!tm->tm_mon)
                    break;
                sprintf(s, "%d", (tm->tm_mon - 1) / 3 + 1);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_CC:
                if (is_interval)    /* straight calculation */
                    i = tm->tm_year / 100;
                else
                {
                    if (tm->tm_year > 0)
                        /* Century 20 == 1901 - 2000 */
                        i = (tm->tm_year - 1) / 100 + 1;
                    else
                        /* Century 6BC == 600BC - 501BC */
                        i = tm->tm_year / 100 - 1;
                }
                if (i <= 99 && i >= -99)
                    sprintf(s, "%0*d", IS_SUFFIX_FM(n->suffix) ? 0 : (i >= 0) ? 2 : 3, i);
                else
                    sprintf(s, "%d", i);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_Y_YYY:
                i = ADJUST_YEAR(tm->tm_year, is_interval) / 1000;
                sprintf(s, "%d,%03d", i,
                        ADJUST_YEAR(tm->tm_year, is_interval) - (i * 1000));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_YYYY:
            case DCH_IYYY:
                sprintf(s, "%0*d",
                        IS_SUFFIX_FM(n->suffix) ? 0 :
                        (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 4 : 5,
                        (n->key->id == DCH_YYYY ?
                         ADJUST_YEAR(tm->tm_year, is_interval) :
                         ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                  tm->tm_mon,
                                                  tm->tm_mday),
                                     is_interval)));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_YYY:
            case DCH_IYY:
                sprintf(s, "%0*d",
                        IS_SUFFIX_FM(n->suffix) ? 0 :
                        (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 3 : 4,
                        (n->key->id == DCH_YYY ?
                         ADJUST_YEAR(tm->tm_year, is_interval) :
                         ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                  tm->tm_mon,
                                                  tm->tm_mday),
                                     is_interval)) % 1000);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_YY:
            case DCH_IY:
                sprintf(s, "%0*d",
                        IS_SUFFIX_FM(n->suffix) ? 0 :
                        (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 2 : 3,
                        (n->key->id == DCH_YY ?
                         ADJUST_YEAR(tm->tm_year, is_interval) :
                         ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                  tm->tm_mon,
                                                  tm->tm_mday),
                                     is_interval)) % 100);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_Y:
            case DCH_I:
                sprintf(s, "%1d",
                        (n->key->id == DCH_Y ?
                         ADJUST_YEAR(tm->tm_year, is_interval) :
                         ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                  tm->tm_mon,
                                                  tm->tm_mday),
                                     is_interval)) % 10);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_RM:
                /* FALLTHROUGH */
            case DCH_rm:
 
                /*
                 * For intervals, values like '12 month' will be reduced to 0
                 * month and some years.  These should be processed.
                 */
                if (!tm->tm_mon && !tm->tm_year)
                    break;
                else
                {
                    int         mon = 0;
                    const char *const *months;
 
                    if (n->key->id == DCH_RM)
                        months = rm_months_upper;
                    else
                        months = rm_months_lower;
 
                    /*
                     * Compute the position in the roman-numeral array.  Note
                     * that the contents of the array are reversed, December
                     * being first and January last.
                     */
                    if (tm->tm_mon == 0)
                    {
                        /*
                         * This case is special, and tracks the case of full
                         * interval years.
                         */
                        mon = tm->tm_year >= 0 ? 0 : MONTHS_PER_YEAR - 1;
                    }
                    else if (tm->tm_mon < 0)
                    {
                        /*
                         * Negative case.  In this case, the calculation is
                         * reversed, where -1 means December, -2 November,
                         * etc.
                         */
                        mon = -1 * (tm->tm_mon + 1);
                    }
                    else
                    {
                        /*
                         * Common case, with a strictly positive value.  The
                         * position in the array matches with the value of
                         * tm_mon.
                         */
                        mon = MONTHS_PER_YEAR - tm->tm_mon;
                    }
 
                    sprintf(s, "%*s", IS_SUFFIX_FM(n->suffix) ? 0 : -4,
                            months[mon]);
                    s += strlen(s);
                }
                break;
            case DCH_W:
                sprintf(s, "%d", (tm->tm_mday - 1) / 7 + 1);
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
            case DCH_J:
                sprintf(s, "%d", date2j(tm->tm_year, tm->tm_mon, tm->tm_mday));
                if (IS_SUFFIX_THth(n->suffix))
                    str_numth(s, s, SUFFIX_TH_TYPE(n->suffix));
                s += strlen(s);
                break;
        }
    }
 
    *s = '\0';
}

References A_D_STR, a_d_STR, A_M_STR, a_m_STR, AD_STR, ad_STR, ADJUST_YEAR, AM_STR, am_STR, asc_tolower_z(), asc_toupper_z(), B_C_STR, b_c_STR, BC_STR, bc_STR, cache_locale_time(), FormatNode::character, collid, date2isoweek(), date2isoyear(), date2isoyearday(), date2j(), days, days_short, DCH_A_D, DCH_a_d, DCH_A_M, DCH_a_m, DCH_AD, DCH_ad, DCH_AM, DCH_am, DCH_B_C, DCH_b_c, DCH_BC, DCH_bc, DCH_CC, DCH_D, DCH_DAY, DCH_Day, DCH_day, DCH_DD, DCH_DDD, DCH_DY, DCH_Dy, DCH_dy, DCH_FF1, DCH_FF2, DCH_FF3, DCH_FF4, DCH_FF5, DCH_FF6, DCH_HH, DCH_HH12, DCH_HH24, DCH_I, DCH_ID, DCH_IDDD, DCH_IW, DCH_IY, DCH_IYY, DCH_IYYY, DCH_J, DCH_MAX_ITEM_SIZ, DCH_MI, DCH_MM, DCH_MON, DCH_Mon, DCH_mon, DCH_MONTH, DCH_Month, DCH_month, DCH_MS, DCH_OF, DCH_P_M, DCH_p_m, DCH_PM, DCH_pm, DCH_Q, DCH_RM, DCH_rm, DCH_SS, DCH_SSSS, DCH_to_char_fsec, DCH_TZ, DCH_tz, DCH_TZH, DCH_TZM, DCH_US, DCH_W, DCH_WW, DCH_Y, DCH_Y_YYY, DCH_YY, DCH_YYY, DCH_YYYY, ereport, errcode(), errmsg(), ERROR, TmToChar::fsec, HOURS_PER_DAY, i, KeyWord::id, INVALID_FOR_INTERVAL, IS_SUFFIX_FM(), IS_SUFFIX_THth(), IS_SUFFIX_TM(), FormatNode::key, KeyWord::len, localized_abbrev_days, localized_abbrev_months, localized_full_days, localized_full_months, months, months_full, MONTHS_PER_YEAR, NODE_TYPE_ACTION, NODE_TYPE_END, P_M_STR, p_m_STR, pfree(), PM_STR, pm_STR, rm_months_lower, rm_months_upper, SECS_PER_HOUR, SECS_PER_MINUTE, sprintf, str, str_initcap_z(), str_numth(), str_tolower_z(), str_toupper_z(), FormatNode::suffix, SUFFIX_TH_TYPE(), TmToChar::tm, tm, pg_tm::tm_gmtoff, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, TM_SUFFIX_LEN, pg_tm::tm_wday, pg_tm::tm_yday, pg_tm::tm_year, tmtcTzn, and FormatNode::type.

Referenced by datetime_to_char_body().

do_to_timestamp()

static bool do_to_timestamp ( const text *  date_txt, const text *  fmt, Oid  collid, bool  std, struct pg_tm *  tm, fsec_t *  fsec, struct fmt_tz *  tz, int *  fprec, uint32 *  flags, Node *  escontext  )

static

Definition at line 4380 of file formatting.c.

{
    FormatNode *format = NULL;
    TmFromChar  tmfc = {0};
    int         fmt_len;
    char       *date_str;
    int         fmask;
    bool        incache = false;
 
    Assert(tm != NULL);
    Assert(fsec != NULL);
 
    date_str = text_to_cstring(date_txt);
 
    ZERO_tm(tm);
    *fsec = 0;
    tz->has_tz = false;
    if (fprec)
        *fprec = 0;
    if (flags)
        *flags = 0;
    fmask = 0;                  /* bit mask for ValidateDate() */
 
    fmt_len = VARSIZE_ANY_EXHDR(fmt);
 
    if (fmt_len)
    {
        char       *fmt_str;
 
        fmt_str = text_to_cstring(fmt);
 
        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)
             */
            format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
 
            parse_format(format, fmt_str, DCH_keywords, DCH_suff, DCH_index,
                         DCH_FLAG | (std ? STD_FLAG : 0), NULL);
        }
        else
        {
            /*
             * Use cache buffers
             */
            DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, std);
 
            incache = true;
            format = ent->format;
        }
 
#ifdef DEBUG_TO_FROM_CHAR
        /* dump_node(format, fmt_len); */
        /* dump_index(DCH_keywords, DCH_index); */
#endif
 
        DCH_from_char(format, date_str, &tmfc, collid, std, escontext);
        pfree(fmt_str);
        if (SOFT_ERROR_OCCURRED(escontext))
            goto fail;
 
        if (flags)
            *flags = DCH_datetime_type(format);
 
        if (!incache)
        {
            pfree(format);
            format = NULL;
        }
    }
 
    DEBUG_TMFC(&tmfc);
 
    /*
     * Convert to_date/to_timestamp input fields to standard 'tm'
     */
    if (tmfc.ssss)
    {
        int         x = tmfc.ssss;
 
        tm->tm_hour = x / SECS_PER_HOUR;
        x %= SECS_PER_HOUR;
        tm->tm_min = x / SECS_PER_MINUTE;
        x %= SECS_PER_MINUTE;
        tm->tm_sec = x;
    }
 
    if (tmfc.ss)
        tm->tm_sec = tmfc.ss;
    if (tmfc.mi)
        tm->tm_min = tmfc.mi;
    if (tmfc.hh)
        tm->tm_hour = tmfc.hh;
 
    if (tmfc.clock_12_hour)
    {
        if (tm->tm_hour < 1 || tm->tm_hour > HOURS_PER_DAY / 2)
        {
            errsave(escontext,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("hour \"%d\" is invalid for the 12-hour clock", tm->tm_hour),
                     errhint("Use the 24-hour clock, or give an hour between 1 and 12.")));
            goto fail;
        }
 
        if (tmfc.pm && tm->tm_hour < HOURS_PER_DAY / 2)
            tm->tm_hour += HOURS_PER_DAY / 2;
        else if (!tmfc.pm && tm->tm_hour == HOURS_PER_DAY / 2)
            tm->tm_hour = 0;
    }
 
    if (tmfc.year)
    {
        /*
         * If CC and YY (or Y) are provided, use YY as 2 low-order digits for
         * the year in the given century.  Keep in mind that the 21st century
         * AD runs from 2001-2100, not 2000-2099; 6th century BC runs from
         * 600BC to 501BC.
         */
        if (tmfc.cc && tmfc.yysz <= 2)
        {
            if (tmfc.bc)
                tmfc.cc = -tmfc.cc;
            tm->tm_year = tmfc.year % 100;
            if (tm->tm_year)
            {
                int         tmp;
 
                if (tmfc.cc >= 0)
                {
                    /* tm->tm_year += (tmfc.cc - 1) * 100; */
                    tmp = tmfc.cc - 1;
                    if (pg_mul_s32_overflow(tmp, 100, &tmp) ||
                        pg_add_s32_overflow(tm->tm_year, tmp, &tm->tm_year))
                    {
                        DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                                           text_to_cstring(date_txt), "timestamp",
                                           escontext);
                        goto fail;
                    }
                }
                else
                {
                    /* tm->tm_year = (tmfc.cc + 1) * 100 - tm->tm_year + 1; */
                    tmp = tmfc.cc + 1;
                    if (pg_mul_s32_overflow(tmp, 100, &tmp) ||
                        pg_sub_s32_overflow(tmp, tm->tm_year, &tmp) ||
                        pg_add_s32_overflow(tmp, 1, &tm->tm_year))
                    {
                        DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                                           text_to_cstring(date_txt), "timestamp",
                                           escontext);
                        goto fail;
                    }
                }
            }
            else
            {
                /* find century year for dates ending in "00" */
                tm->tm_year = tmfc.cc * 100 + ((tmfc.cc >= 0) ? 0 : 1);
            }
        }
        else
        {
            /* If a 4-digit year is provided, we use that and ignore CC. */
            tm->tm_year = tmfc.year;
            if (tmfc.bc)
                tm->tm_year = -tm->tm_year;
            /* correct for our representation of BC years */
            if (tm->tm_year < 0)
                tm->tm_year++;
        }
        fmask |= DTK_M(YEAR);
    }
    else if (tmfc.cc)
    {
        /* use first year of century */
        if (tmfc.bc)
            tmfc.cc = -tmfc.cc;
        if (tmfc.cc >= 0)
        {
            /* +1 because 21st century started in 2001 */
            /* tm->tm_year = (tmfc.cc - 1) * 100 + 1; */
            if (pg_mul_s32_overflow(tmfc.cc - 1, 100, &tm->tm_year) ||
                pg_add_s32_overflow(tm->tm_year, 1, &tm->tm_year))
            {
                DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                                   text_to_cstring(date_txt), "timestamp",
                                   escontext);
                goto fail;
            }
        }
        else
        {
            /* +1 because year == 599 is 600 BC */
            /* tm->tm_year = tmfc.cc * 100 + 1; */
            if (pg_mul_s32_overflow(tmfc.cc, 100, &tm->tm_year) ||
                pg_add_s32_overflow(tm->tm_year, 1, &tm->tm_year))
            {
                DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                                   text_to_cstring(date_txt), "timestamp",
                                   escontext);
                goto fail;
            }
        }
        fmask |= DTK_M(YEAR);
    }
 
    if (tmfc.j)
    {
        j2date(tmfc.j, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
        fmask |= DTK_DATE_M;
    }
 
    if (tmfc.ww)
    {
        if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
        {
            /*
             * If tmfc.d is not set, then the date is left at the beginning of
             * the ISO week (Monday).
             */
            if (tmfc.d)
                isoweekdate2date(tmfc.ww, tmfc.d, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
            else
                isoweek2date(tmfc.ww, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
            fmask |= DTK_DATE_M;
        }
        else
        {
            /* tmfc.ddd = (tmfc.ww - 1) * 7 + 1; */
            if (pg_sub_s32_overflow(tmfc.ww, 1, &tmfc.ddd) ||
                pg_mul_s32_overflow(tmfc.ddd, 7, &tmfc.ddd) ||
                pg_add_s32_overflow(tmfc.ddd, 1, &tmfc.ddd))
            {
                DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                                   date_str, "timestamp", escontext);
                goto fail;
            }
        }
    }
 
    if (tmfc.w)
    {
        /* tmfc.dd = (tmfc.w - 1) * 7 + 1; */
        if (pg_sub_s32_overflow(tmfc.w, 1, &tmfc.dd) ||
            pg_mul_s32_overflow(tmfc.dd, 7, &tmfc.dd) ||
            pg_add_s32_overflow(tmfc.dd, 1, &tmfc.dd))
        {
            DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                               date_str, "timestamp", escontext);
            goto fail;
        }
    }
    if (tmfc.dd)
    {
        tm->tm_mday = tmfc.dd;
        fmask |= DTK_M(DAY);
    }
    if (tmfc.mm)
    {
        tm->tm_mon = tmfc.mm;
        fmask |= DTK_M(MONTH);
    }
 
    if (tmfc.ddd && (tm->tm_mon <= 1 || tm->tm_mday <= 1))
    {
        /*
         * The month and day field have not been set, so we use the
         * day-of-year field to populate them.  Depending on the date mode,
         * this field may be interpreted as a Gregorian day-of-year, or an ISO
         * week date day-of-year.
         */
 
        if (!tm->tm_year && !tmfc.bc)
        {
            errsave(escontext,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("cannot calculate day of year without year information")));
            goto fail;
        }
 
        if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
        {
            int         j0;     /* zeroth day of the ISO year, in Julian */
 
            j0 = isoweek2j(tm->tm_year, 1) - 1;
 
            j2date(j0 + tmfc.ddd, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
            fmask |= DTK_DATE_M;
        }
        else
        {
            const int  *y;
            int         i;
 
            static const int ysum[2][13] = {
                {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
            {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
 
            y = ysum[isleap(tm->tm_year)];
 
            for (i = 1; i <= MONTHS_PER_YEAR; i++)
            {
                if (tmfc.ddd <= y[i])
                    break;
            }
            if (tm->tm_mon <= 1)
                tm->tm_mon = i;
 
            if (tm->tm_mday <= 1)
                tm->tm_mday = tmfc.ddd - y[i - 1];
 
            fmask |= DTK_M(MONTH) | DTK_M(DAY);
        }
    }
 
    if (tmfc.ms)
    {
        int         tmp = 0;
 
        /* *fsec += tmfc.ms * 1000; */
        if (pg_mul_s32_overflow(tmfc.ms, 1000, &tmp) ||
            pg_add_s32_overflow(*fsec, tmp, fsec))
        {
            DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                               date_str, "timestamp", escontext);
            goto fail;
        }
    }
    if (tmfc.us)
        *fsec += tmfc.us;
    if (fprec)
        *fprec = tmfc.ff;       /* fractional precision, if specified */
 
    /* Range-check date fields according to bit mask computed above */
    if (fmask != 0)
    {
        /* We already dealt with AD/BC, so pass isjulian = true */
        int         dterr = ValidateDate(fmask, true, false, false, tm);
 
        if (dterr != 0)
        {
            /*
             * Force the error to be DTERR_FIELD_OVERFLOW even if ValidateDate
             * said DTERR_MD_FIELD_OVERFLOW, because we don't want to print an
             * irrelevant hint about datestyle.
             */
            DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                               date_str, "timestamp", escontext);
            goto fail;
        }
    }
 
    /* Range-check time fields too */
    if (tm->tm_hour < 0 || tm->tm_hour >= HOURS_PER_DAY ||
        tm->tm_min < 0 || tm->tm_min >= MINS_PER_HOUR ||
        tm->tm_sec < 0 || tm->tm_sec >= SECS_PER_MINUTE ||
        *fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC)
    {
        DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                           date_str, "timestamp", escontext);
        goto fail;
    }
 
    /*
     * If timezone info was present, reduce it to a GMT offset.  (We cannot do
     * this until we've filled all of the tm struct, since the zone's offset
     * might be time-varying.)
     */
    if (tmfc.tzsign)
    {
        /* TZH and/or TZM fields */
        if (tmfc.tzh < 0 || tmfc.tzh > MAX_TZDISP_HOUR ||
            tmfc.tzm < 0 || tmfc.tzm >= MINS_PER_HOUR)
        {
            DateTimeParseError(DTERR_TZDISP_OVERFLOW, NULL,
                               date_str, "timestamp", escontext);
            goto fail;
        }
 
        tz->has_tz = true;
        tz->gmtoffset = (tmfc.tzh * MINS_PER_HOUR + tmfc.tzm) * SECS_PER_MINUTE;
        /* note we are flipping the sign convention here */
        if (tmfc.tzsign > 0)
            tz->gmtoffset = -tz->gmtoffset;
    }
    else if (tmfc.has_tz)
    {
        /* TZ field */
        tz->has_tz = true;
        if (tmfc.tzp == NULL)
        {
            /* fixed-offset abbreviation; flip the sign convention */
            tz->gmtoffset = -tmfc.gmtoffset;
        }
        else
        {
            /* dynamic-offset abbreviation, resolve using specified time */
            tz->gmtoffset = DetermineTimeZoneAbbrevOffset(tm, tmfc.abbrev,
                                                          tmfc.tzp);
        }
    }
 
    DEBUG_TM(tm);
 
    if (format && !incache)
        pfree(format);
    pfree(date_str);
 
    return true;
 
fail:
    if (format && !incache)
        pfree(format);
    pfree(date_str);
 
    return false;
}

References TmFromChar::abbrev, Assert(), TmFromChar::bc, TmFromChar::cc, TmFromChar::clock_12_hour, collid, TmFromChar::d, DateTimeParseError(), DAY, DCH_cache_fetch(), DCH_CACHE_SIZE, DCH_datetime_type(), DCH_FLAG, DCH_from_char(), DCH_index, DCH_keywords, DCH_suff, TmFromChar::dd, TmFromChar::ddd, DEBUG_TM, DEBUG_TMFC, DetermineTimeZoneAbbrevOffset(), DTERR_FIELD_OVERFLOW, DTERR_TZDISP_OVERFLOW, DTK_DATE_M, DTK_M, errcode(), errhint(), errmsg(), errsave, TmFromChar::ff, DCHCacheEntry::format, format, FROM_CHAR_DATE_ISOWEEK, TmFromChar::gmtoffset, fmt_tz::gmtoffset, TmFromChar::has_tz, fmt_tz::has_tz, TmFromChar::hh, HOURS_PER_DAY, i, INT64CONST, isleap, isoweek2date(), isoweek2j(), isoweekdate2date(), TmFromChar::j, j2date(), MAX_TZDISP_HOUR, TmFromChar::mi, MINS_PER_HOUR, TmFromChar::mm, TmFromChar::mode, MONTH, MONTHS_PER_YEAR, TmFromChar::ms, palloc(), parse_format(), pfree(), pg_add_s32_overflow(), pg_mul_s32_overflow(), pg_sub_s32_overflow(), TmFromChar::pm, SECS_PER_HOUR, SECS_PER_MINUTE, SOFT_ERROR_OCCURRED, TmFromChar::ss, TmFromChar::ssss, STD_FLAG, text_to_cstring(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, TmFromChar::tzh, TmFromChar::tzm, TmFromChar::tzp, TmFromChar::tzsign, TmFromChar::us, USECS_PER_SEC, ValidateDate(), VARSIZE_ANY_EXHDR(), TmFromChar::w, TmFromChar::ww, x, y, TmFromChar::year, YEAR, TmFromChar::yysz, and ZERO_tm.

Referenced by parse_datetime(), to_date(), and to_timestamp().

fill_str()

static void fill_str ( char *  str, int  c, int  max  )

static

Definition at line 4815 of file formatting.c.

{
    memset(str, c, max);
    str[max] = '\0';
}

References str.

Referenced by float4_to_char(), float8_to_char(), int4_to_char(), int8_to_char(), int_to_roman(), and numeric_to_char().

float4_to_char()

Datum float4_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 6624 of file formatting.c.

{
    float4      value = PG_GETARG_FLOAT4(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    NUMDesc     Num;
    FormatNode *format;
    text       *result;
    bool        shouldFree;
    int         out_pre_spaces = 0,
                sign = 0;
    char       *numstr,
               *p;
 
    NUM_TOCHAR_prepare;
 
    if (IS_ROMAN(&Num))
    {
        int32       intvalue;
 
        /* See notes in ftoi4() */
        value = rint(value);
        /* On overflow, just use PG_INT32_MAX; int_to_roman will cope */
        if (!isnan(value) && FLOAT4_FITS_IN_INT32(value))
            intvalue = (int32) value;
        else
            intvalue = PG_INT32_MAX;
        numstr = int_to_roman(intvalue);
    }
    else if (IS_EEEE(&Num))
    {
        if (isnan(value) || isinf(value))
        {
            /*
             * Allow 6 characters for the leading sign, the decimal point,
             * "e", the exponent's sign and two exponent digits.
             */
            numstr = (char *) palloc(Num.pre + Num.post + 7);
            fill_str(numstr, '#', Num.pre + Num.post + 6);
            *numstr = ' ';
            *(numstr + Num.pre + 1) = '.';
        }
        else
        {
            numstr = psprintf("%+.*e", Num.post, value);
 
            /*
             * Swap a leading positive sign for a space.
             */
            if (*numstr == '+')
                *numstr = ' ';
        }
    }
    else
    {
        float4      val = value;
        char       *orgnum;
        size_t      numstr_pre_len;
 
        if (IS_MULTI(&Num))
        {
            float       multi = pow((double) 10, (double) Num.multi);
 
            val = value * multi;
            Num.pre += Num.multi;
        }
 
        orgnum = psprintf("%.0f", fabs(val));
        numstr_pre_len = strlen(orgnum);
 
        /* adjust post digits to fit max float digits */
        if (numstr_pre_len >= FLT_DIG)
            Num.post = 0;
        else if (numstr_pre_len + Num.post > FLT_DIG)
            Num.post = FLT_DIG - numstr_pre_len;
        orgnum = psprintf("%.*f", Num.post, val);
 
        if (*orgnum == '-')
        {                       /* < 0 */
            sign = '-';
            numstr = orgnum + 1;
        }
        else
        {
            sign = '+';
            numstr = orgnum;
        }
 
        if ((p = strchr(numstr, '.')))
            numstr_pre_len = p - numstr;
        else
            numstr_pre_len = strlen(numstr);
 
        /* needs padding? */
        if (numstr_pre_len < Num.pre)
            out_pre_spaces = Num.pre - numstr_pre_len;
        /* overflowed prefix digit format? */
        else if (numstr_pre_len > Num.pre)
        {
            numstr = (char *) palloc(Num.pre + Num.post + 2);
            fill_str(numstr, '#', Num.pre + Num.post + 1);
            *(numstr + Num.pre) = '.';
        }
    }

References fill_str(), FLOAT4_FITS_IN_INT32, format, int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, palloc(), PG_GETARG_FLOAT4, PG_GETARG_TEXT_PP, PG_INT32_MAX, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, psprintf(), sign, val, and value.

float8_to_char()

Datum float8_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 6736 of file formatting.c.

{
    float8      value = PG_GETARG_FLOAT8(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    NUMDesc     Num;
    FormatNode *format;
    text       *result;
    bool        shouldFree;
    int         out_pre_spaces = 0,
                sign = 0;
    char       *numstr,
               *p;
 
    NUM_TOCHAR_prepare;
 
    if (IS_ROMAN(&Num))
    {
        int32       intvalue;
 
        /* See notes in dtoi4() */
        value = rint(value);
        /* On overflow, just use PG_INT32_MAX; int_to_roman will cope */
        if (!isnan(value) && FLOAT8_FITS_IN_INT32(value))
            intvalue = (int32) value;
        else
            intvalue = PG_INT32_MAX;
        numstr = int_to_roman(intvalue);
    }
    else if (IS_EEEE(&Num))
    {
        if (isnan(value) || isinf(value))
        {
            /*
             * Allow 6 characters for the leading sign, the decimal point,
             * "e", the exponent's sign and two exponent digits.
             */
            numstr = (char *) palloc(Num.pre + Num.post + 7);
            fill_str(numstr, '#', Num.pre + Num.post + 6);
            *numstr = ' ';
            *(numstr + Num.pre + 1) = '.';
        }
        else
        {
            numstr = psprintf("%+.*e", Num.post, value);
 
            /*
             * Swap a leading positive sign for a space.
             */
            if (*numstr == '+')
                *numstr = ' ';
        }
    }
    else
    {
        float8      val = value;
        char       *orgnum;
        size_t      numstr_pre_len;
 
        if (IS_MULTI(&Num))
        {
            double      multi = pow((double) 10, (double) Num.multi);
 
            val = value * multi;
            Num.pre += Num.multi;
        }
 
        orgnum = psprintf("%.0f", fabs(val));
        numstr_pre_len = strlen(orgnum);
 
        /* adjust post digits to fit max double digits */
        if (numstr_pre_len >= DBL_DIG)
            Num.post = 0;
        else if (numstr_pre_len + Num.post > DBL_DIG)
            Num.post = DBL_DIG - numstr_pre_len;
        orgnum = psprintf("%.*f", Num.post, val);
 
        if (*orgnum == '-')
        {                       /* < 0 */
            sign = '-';
            numstr = orgnum + 1;
        }
        else
        {
            sign = '+';
            numstr = orgnum;
        }
 
        if ((p = strchr(numstr, '.')))
            numstr_pre_len = p - numstr;
        else
            numstr_pre_len = strlen(numstr);
 
        /* needs padding? */
        if (numstr_pre_len < Num.pre)
            out_pre_spaces = Num.pre - numstr_pre_len;
        /* overflowed prefix digit format? */
        else if (numstr_pre_len > Num.pre)
        {
            numstr = (char *) palloc(Num.pre + Num.post + 2);
            fill_str(numstr, '#', Num.pre + Num.post + 1);
            *(numstr + Num.pre) = '.';
        }
    }

References fill_str(), FLOAT8_FITS_IN_INT32, format, int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, palloc(), PG_GETARG_FLOAT8, PG_GETARG_TEXT_PP, PG_INT32_MAX, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, psprintf(), sign, val, and value.

from_char_parse_int()

static int from_char_parse_int ( int *  dest, const char **  src, FormatNode *  node, Node *  escontext  )

static

Definition at line 2271 of file formatting.c.

{
    return from_char_parse_int_len(dest, src, node->key->len, node, escontext);
}

References generate_unaccent_rules::dest, from_char_parse_int_len(), FormatNode::key, and KeyWord::len.

Referenced by DCH_from_char().

from_char_parse_int_len()

static int from_char_parse_int_len ( int *  dest, const char **  src, const size_t  len, FormatNode *  node, Node *  escontext  )

static

Definition at line 2176 of file formatting.c.

{
    long        result;
    char        copy[DCH_MAX_ITEM_SIZ + 1];
    const char *init = *src;
    size_t      used;
 
    /*
     * Skip any whitespace before parsing the integer.
     */
    *src += strspace_len(*src);
 
    Assert(len <= DCH_MAX_ITEM_SIZ);
    used = strlcpy(copy, *src, len + 1);
 
    if (IS_SUFFIX_FM(node->suffix) || is_next_separator(node))
    {
        /*
         * This node is in Fill Mode, or the next node is known to be a
         * non-digit value, so we just slurp as many characters as we can get.
         */
        char       *endptr;
 
        errno = 0;
        result = strtol(init, &endptr, 10);
        *src = endptr;
    }
    else
    {
        /*
         * We need to pull exactly the number of characters given in 'len' out
         * of the string, and convert those.
         */
        char       *last;
 
        if (used < len)
            ereturn(escontext, -1,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("source string too short for \"%s\" formatting field",
                            node->key->name),
                     errdetail("Field requires %zu characters, but only %zu remain.",
                               len, used),
                     errhint("If your source string is not fixed-width, try using the \"FM\" modifier.")));
 
        errno = 0;
        result = strtol(copy, &last, 10);
        used = last - copy;
 
        if (used > 0 && used < len)
            ereturn(escontext, -1,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("invalid value \"%s\" for \"%s\"",
                            copy, node->key->name),
                     errdetail("Field requires %zu characters, but only %zu could be parsed.",
                               len, used),
                     errhint("If your source string is not fixed-width, try using the \"FM\" modifier.")));
 
        *src += used;
    }
 
    if (*src == init)
        ereturn(escontext, -1,
                (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                 errmsg("invalid value \"%s\" for \"%s\"",
                        copy, node->key->name),
                 errdetail("Value must be an integer.")));
 
    if (errno == ERANGE || result < INT_MIN || result > INT_MAX)
        ereturn(escontext, -1,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("value for \"%s\" in source string is out of range",
                        node->key->name),
                 errdetail("Value must be in the range %d to %d.",
                           INT_MIN, INT_MAX)));
 
    if (dest != NULL)
    {
        if (!from_char_set_int(dest, (int) result, node, escontext))
            return -1;
    }
 
    return *src - init;
}

References Assert(), DCH_MAX_ITEM_SIZ, generate_unaccent_rules::dest, ereturn, errcode(), errdetail(), errhint(), errmsg(), from_char_set_int(), init, is_next_separator(), IS_SUFFIX_FM(), FormatNode::key, len, KeyWord::name, strlcpy(), strspace_len(), and FormatNode::suffix.

Referenced by DCH_from_char(), and from_char_parse_int().

from_char_seq_search()

static bool from_char_seq_search ( int *  dest, const char **  src, const char *const *  array, char **  localized_array, Oid  collid, FormatNode *  node, Node *  escontext  )

static

Definition at line 2425 of file formatting.c.

{
    size_t      len;
 
    if (localized_array == NULL)
        *dest = seq_search_ascii(*src, array, &len);
    else
        *dest = seq_search_localized(*src, localized_array, &len, collid);
 
    if (len <= 0)
    {
        /*
         * In the error report, truncate the string at the next whitespace (if
         * any) to avoid including irrelevant data.
         */
        char       *copy = pstrdup(*src);
 
        for (char *c = copy; *c; c++)
        {
            if (scanner_isspace(*c))
            {
                *c = '\0';
                break;
            }
        }
 
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                 errmsg("invalid value \"%s\" for \"%s\"",
                        copy, node->key->name),
                 errdetail("The given value did not match any of the allowed values for this field.")));
    }
    *src += len;
    return true;
}

References collid, generate_unaccent_rules::dest, ereturn, errcode(), errdetail(), errmsg(), FormatNode::key, len, KeyWord::name, pstrdup(), scanner_isspace(), seq_search_ascii(), and seq_search_localized().

Referenced by DCH_from_char().

from_char_set_int()

static bool from_char_set_int ( int *  dest, const int  value, const FormatNode *  node, Node *  escontext  )

static

Definition at line 2141 of file formatting.c.

{
    if (*dest != 0 && *dest != value)
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                 errmsg("conflicting values for \"%s\" field in formatting string",
                        node->key->name),
                 errdetail("This value contradicts a previous setting for the same field type.")));
    *dest = value;
    return true;
}

References generate_unaccent_rules::dest, ereturn, errcode(), errdetail(), errmsg(), FormatNode::key, KeyWord::name, and value.

Referenced by DCH_from_char(), and from_char_parse_int_len().

from_char_set_mode()

static bool from_char_set_mode ( TmFromChar *  tmfc, const FromCharDateMode  mode, Node *  escontext  )

static

Definition at line 2115 of file formatting.c.

{
    if (mode != FROM_CHAR_DATE_NONE)
    {
        if (tmfc->mode == FROM_CHAR_DATE_NONE)
            tmfc->mode = mode;
        else if (tmfc->mode != mode)
            ereturn(escontext, false,
                    (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                     errmsg("invalid combination of date conventions"),
                     errhint("Do not mix Gregorian and ISO week date conventions in a formatting template.")));
    }
    return true;
}

References ereturn, errcode(), errhint(), errmsg(), FROM_CHAR_DATE_NONE, TmFromChar::mode, and mode.

Referenced by DCH_from_char().

get_last_relevant_decnum()

static const char * get_last_relevant_decnum ( const char *  num )

static

Definition at line 5294 of file formatting.c.

{
    const char *result,
               *p = strchr(num, '.');
 
#ifdef DEBUG_TO_FROM_CHAR
    elog(DEBUG_elog_output, "get_last_relevant_decnum()");
#endif
 
    if (!p)
        return NULL;
 
    result = p;
 
    while (*(++p))
    {
        if (*p != '0')
            result = p;
    }
 
    return result;
}

References elog.

Referenced by NUM_processor().

get_th()

static const char * get_th ( const char *  num, enum TH_Case  type  )

static

Definition at line 1555 of file formatting.c.

{
    size_t      len = strlen(num);
    char        last;
 
    Assert(len > 0);
 
    last = num[len - 1];
    if (!isdigit((unsigned char) last))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("\"%s\" is not a number", num)));
 
    /*
     * All "teens" (<x>1[0-9]) get 'TH/th', while <x>[02-9][123] still get
     * 'ST/st', 'ND/nd', 'RD/rd', respectively
     */
    if (len > 1 && num[len - 2] == '1')
        last = 0;
 
    switch (last)
    {
        case '1':
            if (type == TH_UPPER)
                return numTH[0];
            return numth[0];
        case '2':
            if (type == TH_UPPER)
                return numTH[1];
            return numth[1];
        case '3':
            if (type == TH_UPPER)
                return numTH[2];
            return numth[2];
        default:
            if (type == TH_UPPER)
                return numTH[3];
            return numth[3];
    }
}

References Assert(), ereport, errcode(), errmsg(), ERROR, len, numTH, numth, TH_UPPER, and type.

Referenced by NUM_processor(), and str_numth().

index_seq_search()

static const KeyWord * index_seq_search ( const char *  str, const KeyWord *  kw, const int *  index  )

static

Definition at line 1134 of file formatting.c.

{
    int         poz;
 
    if (!KeyWord_INDEX_FILTER(*str))
        return NULL;
 
    if ((poz = index[*str - ' ']) > -1)
    {
        const KeyWord *k = kw + poz;
 
        do
        {
            if (strncmp(str, k->name, k->len) == 0)
                return k;
            k++;
            if (!k->name)
                return NULL;
        } while (*str == *k->name);
    }
    return NULL;
}

References KeyWord_INDEX_FILTER, KeyWord::len, KeyWord::name, and str.

Referenced by parse_format().

int4_to_char()

Datum int4_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 6420 of file formatting.c.

{
    int32       value = PG_GETARG_INT32(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    NUMDesc     Num;
    FormatNode *format;
    text       *result;
    bool        shouldFree;
    int         out_pre_spaces = 0,
                sign = 0;
    char       *numstr,
               *orgnum;
 
    NUM_TOCHAR_prepare;
 
    /*
     * On DateType depend part (int32)
     */
    if (IS_ROMAN(&Num))
        numstr = int_to_roman(value);
    else if (IS_EEEE(&Num))
    {
        /* we can do it easily because float8 won't lose any precision */
        float8      val = (float8) value;
 
        orgnum = (char *) psprintf("%+.*e", Num.post, val);
 
        /*
         * Swap a leading positive sign for a space.
         */
        if (*orgnum == '+')
            *orgnum = ' ';
 
        numstr = orgnum;
    }
    else
    {
        size_t      numstr_pre_len;
 
        if (IS_MULTI(&Num))
        {
            orgnum = DatumGetCString(DirectFunctionCall1(int4out,
                                                         Int32GetDatum(value * ((int32) pow((double) 10, (double) Num.multi)))));
            Num.pre += Num.multi;
        }
        else
        {
            orgnum = DatumGetCString(DirectFunctionCall1(int4out,
                                                         Int32GetDatum(value)));
        }
 
        if (*orgnum == '-')
        {
            sign = '-';
            orgnum++;
        }
        else
            sign = '+';
 
        numstr_pre_len = strlen(orgnum);
 
        /* post-decimal digits?  Pad out with zeros. */
        if (Num.post)
        {
            numstr = (char *) palloc(numstr_pre_len + Num.post + 2);
            strcpy(numstr, orgnum);
            *(numstr + numstr_pre_len) = '.';
            memset(numstr + numstr_pre_len + 1, '0', Num.post);
            *(numstr + numstr_pre_len + Num.post + 1) = '\0';
        }
        else
            numstr = orgnum;
 
        /* needs padding? */
        if (numstr_pre_len < Num.pre)
            out_pre_spaces = Num.pre - numstr_pre_len;
        /* overflowed prefix digit format? */
        else if (numstr_pre_len > Num.pre)
        {
            numstr = (char *) palloc(Num.pre + Num.post + 2);
            fill_str(numstr, '#', Num.pre + Num.post + 1);
            *(numstr + Num.pre) = '.';
        }
    }

References DatumGetCString(), DirectFunctionCall1, fill_str(), format, Int32GetDatum(), int4out(), int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, palloc(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, psprintf(), sign, val, and value.

int8_to_char()

Datum int8_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 6513 of file formatting.c.

{
    int64       value = PG_GETARG_INT64(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    NUMDesc     Num;
    FormatNode *format;
    text       *result;
    bool        shouldFree;
    int         out_pre_spaces = 0,
                sign = 0;
    char       *numstr,
               *orgnum;
 
    NUM_TOCHAR_prepare;
 
    /*
     * On DateType depend part (int64)
     */
    if (IS_ROMAN(&Num))
    {
        int32       intvalue;
 
        /* On overflow, just use PG_INT32_MAX; int_to_roman will cope */
        if (value <= PG_INT32_MAX && value >= PG_INT32_MIN)
            intvalue = (int32) value;
        else
            intvalue = PG_INT32_MAX;
        numstr = int_to_roman(intvalue);
    }
    else if (IS_EEEE(&Num))
    {
        /* to avoid loss of precision, must go via numeric not float8 */
        orgnum = numeric_out_sci(int64_to_numeric(value),
                                 Num.post);
 
        /*
         * numeric_out_sci() does not emit a sign for positive numbers.  We
         * need to add a space in this case so that positive and negative
         * numbers are aligned.  We don't have to worry about NaN/inf here.
         */
        if (*orgnum != '-')
        {
            numstr = (char *) palloc(strlen(orgnum) + 2);
            *numstr = ' ';
            strcpy(numstr + 1, orgnum);
        }
        else
        {
            numstr = orgnum;
        }
    }
    else
    {
        size_t      numstr_pre_len;
 
        if (IS_MULTI(&Num))
        {
            double      multi = pow((double) 10, (double) Num.multi);
 
            value = DatumGetInt64(DirectFunctionCall2(int8mul,
                                                      Int64GetDatum(value),
                                                      DirectFunctionCall1(dtoi8,
                                                                          Float8GetDatum(multi))));
            Num.pre += Num.multi;
        }
 
        orgnum = DatumGetCString(DirectFunctionCall1(int8out,
                                                     Int64GetDatum(value)));
 
        if (*orgnum == '-')
        {
            sign = '-';
            orgnum++;
        }
        else
            sign = '+';
 
        numstr_pre_len = strlen(orgnum);
 
        /* post-decimal digits?  Pad out with zeros. */
        if (Num.post)
        {
            numstr = (char *) palloc(numstr_pre_len + Num.post + 2);
            strcpy(numstr, orgnum);
            *(numstr + numstr_pre_len) = '.';
            memset(numstr + numstr_pre_len + 1, '0', Num.post);
            *(numstr + numstr_pre_len + Num.post + 1) = '\0';
        }
        else
            numstr = orgnum;
 
        /* needs padding? */
        if (numstr_pre_len < Num.pre)
            out_pre_spaces = Num.pre - numstr_pre_len;
        /* overflowed prefix digit format? */
        else if (numstr_pre_len > Num.pre)
        {
            numstr = (char *) palloc(Num.pre + Num.post + 2);
            fill_str(numstr, '#', Num.pre + Num.post + 1);
            *(numstr + Num.pre) = '.';
        }
    }

References DatumGetCString(), DatumGetInt64(), DirectFunctionCall1, DirectFunctionCall2, dtoi8(), fill_str(), Float8GetDatum(), format, int64_to_numeric(), Int64GetDatum(), int8mul(), int8out(), int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, numeric_out_sci(), palloc(), PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_INT32_MAX, PG_INT32_MIN, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, sign, and value.

int_to_roman()

static char * int_to_roman ( int  number )

static

Definition at line 5005 of file formatting.c.

{
    int         len,
                num;
    char       *result,
                numstr[12];
 
    result = (char *) palloc(MAX_ROMAN_LEN + 1);
    *result = '\0';
 
    /*
     * This range limit is the same as in Oracle(TM).  The difficulty with
     * handling 4000 or more is that we'd need to use more than 3 "M"'s, and
     * more than 3 of the same digit isn't considered a valid Roman string.
     */
    if (number > 3999 || number < 1)
    {
        fill_str(result, '#', MAX_ROMAN_LEN);
        return result;
    }
 
    /* Convert to decimal, then examine each digit */
    len = snprintf(numstr, sizeof(numstr), "%d", number);
    Assert(len > 0 && len <= 4);
 
    for (char *p = numstr; *p != '\0'; p++, --len)
    {
        num = *p - ('0' + 1);
        if (num < 0)
            continue;           /* ignore zeroes */
        /* switch on current column position */
        switch (len)
        {
            case 4:
                while (num-- >= 0)
                    strcat(result, "M");
                break;
            case 3:
                strcat(result, rm100[num]);
                break;
            case 2:
                strcat(result, rm10[num]);
                break;
            case 1:
                strcat(result, rm1[num]);
                break;
        }
    }
    return result;
}

References Assert(), fill_str(), len, MAX_ROMAN_LEN, palloc(), rm1, rm10, rm100, and snprintf.

Referenced by float4_to_char(), float8_to_char(), int4_to_char(), int8_to_char(), and numeric_to_char().

interval_to_char()

Datum interval_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 4031 of file formatting.c.

{
    Interval   *it = PG_GETARG_INTERVAL_P(0);
    text       *fmt = PG_GETARG_TEXT_PP(1),
               *res;
    TmToChar    tmtc;
    struct fmt_tm *tm;
    struct pg_itm tt,
               *itm = &tt;
 
    if (VARSIZE_ANY_EXHDR(fmt) <= 0 || INTERVAL_NOT_FINITE(it))
        PG_RETURN_NULL();
 
    ZERO_tmtc(&tmtc);
    tm = tmtcTm(&tmtc);
 
    interval2itm(*it, itm);
    tmtc.fsec = itm->tm_usec;
    tm->tm_sec = itm->tm_sec;
    tm->tm_min = itm->tm_min;
    tm->tm_hour = itm->tm_hour;
    tm->tm_mday = itm->tm_mday;
    tm->tm_mon = itm->tm_mon;
    tm->tm_year = itm->tm_year;
 
    /* wday is meaningless, yday approximates the total span in days */
    tm->tm_yday = (tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon) * DAYS_PER_MONTH + tm->tm_mday;
 
    if (!(res = datetime_to_char_body(&tmtc, fmt, true, PG_GET_COLLATION())))
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(res);
}

References datetime_to_char_body(), DAYS_PER_MONTH, TmToChar::fsec, if(), interval2itm(), INTERVAL_NOT_FINITE, MONTHS_PER_YEAR, PG_GET_COLLATION, PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, tm, pg_itm::tm_hour, pg_tm::tm_hour, pg_itm::tm_mday, pg_tm::tm_mday, pg_itm::tm_min, pg_tm::tm_min, pg_itm::tm_mon, pg_tm::tm_mon, pg_itm::tm_sec, pg_tm::tm_sec, pg_itm::tm_usec, pg_tm::tm_yday, pg_itm::tm_year, pg_tm::tm_year, tmtcTm, VARSIZE_ANY_EXHDR(), and ZERO_tmtc.

is_next_separator()

static bool is_next_separator ( FormatNode *  n )

static

Definition at line 2036 of file formatting.c.

{
    if (n->type == NODE_TYPE_END)
        return false;
 
    if (n->type == NODE_TYPE_ACTION && IS_SUFFIX_THth(n->suffix))
        return true;
 
    /*
     * Next node
     */
    n++;
 
    /* end of format string is treated like a non-digit separator */
    if (n->type == NODE_TYPE_END)
        return true;
 
    if (n->type == NODE_TYPE_ACTION)
    {
        if (n->key->is_digit)
            return false;
 
        return true;
    }
    else if (n->character[1] == '\0' &&
             isdigit((unsigned char) n->character[0]))
        return false;
 
    return true;                /* some non-digit input (separator) */
}

References FormatNode::character, KeyWord::is_digit, IS_SUFFIX_THth(), FormatNode::key, NODE_TYPE_ACTION, NODE_TYPE_END, FormatNode::suffix, and FormatNode::type.

Referenced by from_char_parse_int_len().

is_separator_char()

static bool is_separator_char ( const char *  str )

static

Definition at line 1172 of file formatting.c.

{
    /* ASCII printable character, but not letter or digit */
    return (*str > 0x20 && *str < 0x7F &&
            !(*str >= 'A' && *str <= 'Z') &&
            !(*str >= 'a' && *str <= 'z') &&
            !(*str >= '0' && *str <= '9'));
}

References str.

Referenced by DCH_from_char(), and parse_format().

IS_SUFFIX_FM()

static bool IS_SUFFIX_FM ( uint8  _s )

inlinestatic

Definition at line 585 of file formatting.c.

{
    return (_s & DCH_SUFFIX_FM);
}

References DCH_SUFFIX_FM.

Referenced by DCH_to_char(), and from_char_parse_int_len().

IS_SUFFIX_TH()

static bool IS_SUFFIX_TH ( uint8  _s )

inlinestatic

Definition at line 560 of file formatting.c.

{
    return (_s & DCH_SUFFIX_TH);
}

References DCH_SUFFIX_TH.

Referenced by IS_SUFFIX_THth().

IS_SUFFIX_th()

static bool IS_SUFFIX_th ( uint8  _s )

inlinestatic

Definition at line 566 of file formatting.c.

{
    return (_s & DCH_SUFFIX_th);
}

References DCH_SUFFIX_th.

Referenced by IS_SUFFIX_THth().

IS_SUFFIX_THth()

static bool IS_SUFFIX_THth ( uint8  _s )

inlinestatic

Definition at line 572 of file formatting.c.

{
    return IS_SUFFIX_TH(_s) || IS_SUFFIX_th(_s);
}

References IS_SUFFIX_TH(), and IS_SUFFIX_th().

Referenced by DCH_to_char(), and is_next_separator().

IS_SUFFIX_TM()

static bool IS_SUFFIX_TM ( uint8  _s )

inlinestatic

Definition at line 591 of file formatting.c.

{
    return (_s & DCH_SUFFIX_TM);
}

References DCH_SUFFIX_TM.

Referenced by DCH_from_char(), and DCH_to_char().

NUM_cache()

static FormatNode * NUM_cache ( int  len, NUMDesc *  Num, const text *  pars_str, bool *  shouldFree  )

static

Definition at line 4942 of file formatting.c.

{
    FormatNode *format = NULL;
    char       *str;
 
    str = text_to_cstring(pars_str);
 
    if (len > NUM_CACHE_SIZE)
    {
        /*
         * Allocate new memory if format picture is bigger than static cache
         * and do not use cache (call parser always)
         */
        format = (FormatNode *) palloc((len + 1) * sizeof(FormatNode));
 
        *shouldFree = true;
 
        memset(Num, 0, sizeof *Num);
 
        parse_format(format, str, NUM_keywords,
                     NULL, NUM_index, NUM_FLAG, Num);
    }
    else
    {
        /*
         * Use cache buffers
         */
        NUMCacheEntry *ent = NUM_cache_fetch(str);
 
        *shouldFree = false;
 
        format = ent->format;
 
        /*
         * Copy cache to used struct
         */
        Num->flag = ent->Num.flag;
        Num->lsign = ent->Num.lsign;
        Num->pre = ent->Num.pre;
        Num->post = ent->Num.post;
        Num->pre_lsign_num = ent->Num.pre_lsign_num;
        Num->need_locale = ent->Num.need_locale;
        Num->multi = ent->Num.multi;
        Num->zero_start = ent->Num.zero_start;
        Num->zero_end = ent->Num.zero_end;
    }
 
#ifdef DEBUG_TO_FROM_CHAR
    /* dump_node(format, len); */
    dump_index(NUM_keywords, NUM_index);
#endif
 
    pfree(str);
    return format;
}

References NUMDesc::flag, NUMCacheEntry::format, format, len, NUMDesc::lsign, NUMDesc::multi, NUMDesc::need_locale, NUMCacheEntry::Num, NUM_cache_fetch(), NUM_CACHE_SIZE, NUM_FLAG, NUM_index, NUM_keywords, palloc(), parse_format(), pfree(), NUMDesc::post, NUMDesc::pre, NUMDesc::pre_lsign_num, str, text_to_cstring(), NUMDesc::zero_end, and NUMDesc::zero_start.

Referenced by numeric_to_number().

NUM_cache_fetch()

static NUMCacheEntry * NUM_cache_fetch ( const char *  str )

static

Definition at line 4915 of file formatting.c.

{
    NUMCacheEntry *ent;
 
    if ((ent = NUM_cache_search(str)) == NULL)
    {
        /*
         * Not in the cache, must run parser and save a new format-picture to
         * the cache.  Do not mark the cache entry valid until parsing
         * succeeds.
         */
        ent = NUM_cache_getnew(str);
 
        memset(&ent->Num, 0, sizeof ent->Num);
 
        parse_format(ent->format, str, NUM_keywords,
                     NULL, NUM_index, NUM_FLAG, &ent->Num);
 
        ent->valid = true;
    }
    return ent;
}

References NUMCacheEntry::format, NUMCacheEntry::Num, NUM_cache_getnew(), NUM_cache_search(), NUM_FLAG, NUM_index, NUM_keywords, parse_format(), str, and NUMCacheEntry::valid.

Referenced by NUM_cache().

NUM_cache_getnew()

static NUMCacheEntry * NUM_cache_getnew ( const char *  str )

static

Definition at line 4835 of file formatting.c.

{
    NUMCacheEntry *ent;
 
    /* Ensure we can advance NUMCounter below */
    NUM_prevent_counter_overflow();
 
    /*
     * If cache is full, remove oldest entry (or recycle first not-valid one)
     */
    if (n_NUMCache >= NUM_CACHE_ENTRIES)
    {
        NUMCacheEntry *old = NUMCache[0];
 
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "Cache is full (%d)", n_NUMCache);
#endif
        if (old->valid)
        {
            for (int i = 1; i < NUM_CACHE_ENTRIES; i++)
            {
                ent = NUMCache[i];
                if (!ent->valid)
                {
                    old = ent;
                    break;
                }
                if (ent->age < old->age)
                    old = ent;
            }
        }
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "OLD: \"%s\" AGE: %d", old->str, old->age);
#endif
        old->valid = false;
        strlcpy(old->str, str, NUM_CACHE_SIZE + 1);
        old->age = (++NUMCounter);
        /* caller is expected to fill format and Num, then set valid */
        return old;
    }
    else
    {
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "NEW (%d)", n_NUMCache);
#endif
        Assert(NUMCache[n_NUMCache] == NULL);
        NUMCache[n_NUMCache] = ent = (NUMCacheEntry *)
            MemoryContextAllocZero(TopMemoryContext, sizeof(NUMCacheEntry));
        ent->valid = false;
        strlcpy(ent->str, str, NUM_CACHE_SIZE + 1);
        ent->age = (++NUMCounter);
        /* caller is expected to fill format and Num, then set valid */
        ++n_NUMCache;
        return ent;
    }
}

References NUMCacheEntry::age, Assert(), elog, i, MemoryContextAllocZero(), n_NUMCache, NUM_CACHE_ENTRIES, NUM_CACHE_SIZE, NUM_prevent_counter_overflow(), NUMCache, NUMCounter, NUMCacheEntry::str, str, strlcpy(), TopMemoryContext, and NUMCacheEntry::valid.

Referenced by NUM_cache_fetch().

NUM_cache_search()

static NUMCacheEntry * NUM_cache_search ( const char *  str )

static

Definition at line 4894 of file formatting.c.

{
    /* Ensure we can advance NUMCounter below */
    NUM_prevent_counter_overflow();
 
    for (int i = 0; i < n_NUMCache; i++)
    {
        NUMCacheEntry *ent = NUMCache[i];
 
        if (ent->valid && strcmp(ent->str, str) == 0)
        {
            ent->age = (++NUMCounter);
            return ent;
        }
    }
 
    return NULL;
}

References NUMCacheEntry::age, i, n_NUMCache, NUM_prevent_counter_overflow(), NUMCache, NUMCounter, NUMCacheEntry::str, str, and NUMCacheEntry::valid.

Referenced by NUM_cache_fetch().

NUM_eat_non_data_chars()

static void NUM_eat_non_data_chars ( NUMProc *  Np, int  n, size_t  input_len  )

static

Definition at line 5725 of file formatting.c.

{
    while (n-- > 0)
    {
        if (OVERLOAD_TEST)
            break;              /* end of input */
        if (strchr("0123456789.,+-", *Np->inout_p) != NULL)
            break;              /* it's a data character */
        Np->inout_p += pg_mblen(Np->inout_p);
    }
}

References NUMProc::inout_p, OVERLOAD_TEST, and pg_mblen().

Referenced by NUM_processor().

NUM_numpart_from_char()

static void NUM_numpart_from_char ( NUMProc *  Np, int  id, size_t  input_len  )

static

Definition at line 5321 of file formatting.c.

{
    bool        isread = false;
 
#ifdef DEBUG_TO_FROM_CHAR
    elog(DEBUG_elog_output, " --- scan start --- id=%s",
         (id == NUM_0 || id == NUM_9) ? "NUM_0/9" : id == NUM_DEC ? "NUM_DEC" : "???");
#endif
 
    if (OVERLOAD_TEST)
        return;
 
    if (*Np->inout_p == ' ')
        Np->inout_p++;
 
    if (OVERLOAD_TEST)
        return;
 
    /*
     * read sign before number
     */
    if (*Np->number == ' ' && (id == NUM_0 || id == NUM_9) &&
        (Np->read_pre + Np->read_post) == 0)
    {
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "Try read sign (%c), locale positive: %s, negative: %s",
             *Np->inout_p, Np->L_positive_sign, Np->L_negative_sign);
#endif
 
        /*
         * locale sign
         */
        if (IS_LSIGN(Np->Num) && Np->Num->lsign == NUM_LSIGN_PRE)
        {
            size_t      x = 0;
 
#ifdef DEBUG_TO_FROM_CHAR
            elog(DEBUG_elog_output, "Try read locale pre-sign (%c)", *Np->inout_p);
#endif
            if ((x = strlen(Np->L_negative_sign)) &&
                AMOUNT_TEST(x) &&
                strncmp(Np->inout_p, Np->L_negative_sign, x) == 0)
            {
                Np->inout_p += x;
                *Np->number = '-';
            }
            else if ((x = strlen(Np->L_positive_sign)) &&
                     AMOUNT_TEST(x) &&
                     strncmp(Np->inout_p, Np->L_positive_sign, x) == 0)
            {
                Np->inout_p += x;
                *Np->number = '+';
            }
        }
        else
        {
#ifdef DEBUG_TO_FROM_CHAR
            elog(DEBUG_elog_output, "Try read simple sign (%c)", *Np->inout_p);
#endif
 
            /*
             * simple + - < >
             */
            if (*Np->inout_p == '-' || (IS_BRACKET(Np->Num) &&
                                        *Np->inout_p == '<'))
            {
                *Np->number = '-';  /* set - */
                Np->inout_p++;
            }
            else if (*Np->inout_p == '+')
            {
                *Np->number = '+';  /* set + */
                Np->inout_p++;
            }
        }
    }
 
    if (OVERLOAD_TEST)
        return;
 
#ifdef DEBUG_TO_FROM_CHAR
    elog(DEBUG_elog_output, "Scan for numbers (%c), current number: '%s'", *Np->inout_p, Np->number);
#endif
 
    /*
     * read digit or decimal point
     */
    if (isdigit((unsigned char) *Np->inout_p))
    {
        if (Np->read_dec && Np->read_post == Np->Num->post)
            return;
 
        *Np->number_p = *Np->inout_p;
        Np->number_p++;
 
        if (Np->read_dec)
            Np->read_post++;
        else
            Np->read_pre++;
 
        isread = true;
 
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "Read digit (%c)", *Np->inout_p);
#endif
    }
    else if (IS_DECIMAL(Np->Num) && Np->read_dec == false)
    {
        /*
         * We need not test IS_LDECIMAL(Np->Num) explicitly here, because
         * Np->decimal is always just "." if we don't have a D format token.
         * So we just unconditionally match to Np->decimal.
         */
        size_t      x = strlen(Np->decimal);
 
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "Try read decimal point (%c)",
             *Np->inout_p);
#endif
        if (x && AMOUNT_TEST(x) && strncmp(Np->inout_p, Np->decimal, x) == 0)
        {
            Np->inout_p += x - 1;
            *Np->number_p = '.';
            Np->number_p++;
            Np->read_dec = true;
            isread = true;
        }
    }
 
    if (OVERLOAD_TEST)
        return;
 
    /*
     * Read sign behind "last" number
     *
     * We need sign detection because determine exact position of post-sign is
     * difficult:
     *
     * FM9999.9999999S     -> 123.001- 9.9S            -> .5- FM9.999999MI ->
     * 5.01-
     */
    if (*Np->number == ' ' && Np->read_pre + Np->read_post > 0)
    {
        /*
         * locale sign (NUM_S) is always anchored behind a last number, if: -
         * locale sign expected - last read char was NUM_0/9 or NUM_DEC - and
         * next char is not digit
         */
        if (IS_LSIGN(Np->Num) && isread &&
            (Np->inout_p + 1) < Np->inout + input_len &&
            !isdigit((unsigned char) *(Np->inout_p + 1)))
        {
            size_t      x;
            char       *tmp = Np->inout_p++;
 
#ifdef DEBUG_TO_FROM_CHAR
            elog(DEBUG_elog_output, "Try read locale post-sign (%c)", *Np->inout_p);
#endif
            if ((x = strlen(Np->L_negative_sign)) &&
                AMOUNT_TEST(x) &&
                strncmp(Np->inout_p, Np->L_negative_sign, x) == 0)
            {
                Np->inout_p += x - 1;   /* -1 .. NUM_processor() do inout_p++ */
                *Np->number = '-';
            }
            else if ((x = strlen(Np->L_positive_sign)) &&
                     AMOUNT_TEST(x) &&
                     strncmp(Np->inout_p, Np->L_positive_sign, x) == 0)
            {
                Np->inout_p += x - 1;   /* -1 .. NUM_processor() do inout_p++ */
                *Np->number = '+';
            }
            if (*Np->number == ' ')
                /* no sign read */
                Np->inout_p = tmp;
        }
 
        /*
         * try read non-locale sign, which happens only if format is not exact
         * and we cannot determine sign position of MI/PL/SG, an example:
         *
         * FM9.999999MI            -> 5.01-
         *
         * if (.... && IS_LSIGN(Np->Num)==false) prevents read wrong formats
         * like to_number('1 -', '9S') where sign is not anchored to last
         * number.
         */
        else if (isread == false && IS_LSIGN(Np->Num) == false &&
                 (IS_PLUS(Np->Num) || IS_MINUS(Np->Num)))
        {
#ifdef DEBUG_TO_FROM_CHAR
            elog(DEBUG_elog_output, "Try read simple post-sign (%c)", *Np->inout_p);
#endif
 
            /*
             * simple + -
             */
            if (*Np->inout_p == '-' || *Np->inout_p == '+')
                /* NUM_processor() do inout_p++ */
                *Np->number = *Np->inout_p;
        }
    }
}

References AMOUNT_TEST, NUMProc::decimal, elog, NUMProc::inout, NUMProc::inout_p, IS_BRACKET, IS_DECIMAL, IS_LSIGN, IS_MINUS, IS_PLUS, NUMProc::L_negative_sign, NUMProc::L_positive_sign, NUMDesc::lsign, NUMProc::Num, NUM_0, NUM_9, NUM_DEC, NUM_LSIGN_PRE, NUMProc::number, NUMProc::number_p, OVERLOAD_TEST, NUMDesc::post, NUMProc::read_dec, NUMProc::read_post, NUMProc::read_pre, and x.

Referenced by NUM_processor().

NUM_numpart_to_char()

static void NUM_numpart_to_char ( NUMProc *  Np, int  id  )

static

Definition at line 5535 of file formatting.c.

{
    int         end;
 
    if (IS_ROMAN(Np->Num))
        return;
 
    /* Note: in this elog() output not set '\0' in 'inout' */
 
#ifdef DEBUG_TO_FROM_CHAR
 
    /*
     * Np->num_curr is number of current item in format-picture, it is not
     * current position in inout!
     */
    elog(DEBUG_elog_output,
         "SIGN_WROTE: %d, CURRENT: %d, NUMBER_P: \"%s\", INOUT: \"%s\"",
         Np->sign_wrote,
         Np->num_curr,
         Np->number_p,
         Np->inout);
#endif
    Np->num_in = false;
 
    /*
     * Write sign if real number will write to output Note: IS_PREDEC_SPACE()
     * handle "9.9" --> " .1"
     */
    if (Np->sign_wrote == false &&
        (Np->num_curr >= Np->out_pre_spaces || (IS_ZERO(Np->Num) && Np->Num->zero_start == Np->num_curr)) &&
        (IS_PREDEC_SPACE(Np) == false || (Np->last_relevant && *Np->last_relevant == '.')))
    {
        if (IS_LSIGN(Np->Num))
        {
            if (Np->Num->lsign == NUM_LSIGN_PRE)
            {
                if (Np->sign == '-')
                    strcpy(Np->inout_p, Np->L_negative_sign);
                else
                    strcpy(Np->inout_p, Np->L_positive_sign);
                Np->inout_p += strlen(Np->inout_p);
                Np->sign_wrote = true;
            }
        }
        else if (IS_BRACKET(Np->Num))
        {
            *Np->inout_p = Np->sign == '+' ? ' ' : '<';
            ++Np->inout_p;
            Np->sign_wrote = true;
        }
        else if (Np->sign == '+')
        {
            if (!IS_FILLMODE(Np->Num))
            {
                *Np->inout_p = ' '; /* Write + */
                ++Np->inout_p;
            }
            Np->sign_wrote = true;
        }
        else if (Np->sign == '-')
        {                       /* Write - */
            *Np->inout_p = '-';
            ++Np->inout_p;
            Np->sign_wrote = true;
        }
    }
 
 
    /*
     * digits / FM / Zero / Dec. point
     */
    if (id == NUM_9 || id == NUM_0 || id == NUM_D || id == NUM_DEC)
    {
        if (Np->num_curr < Np->out_pre_spaces &&
            (Np->Num->zero_start > Np->num_curr || !IS_ZERO(Np->Num)))
        {
            /*
             * Write blank space
             */
            if (!IS_FILLMODE(Np->Num))
            {
                *Np->inout_p = ' '; /* Write ' ' */
                ++Np->inout_p;
            }
        }
        else if (IS_ZERO(Np->Num) &&
                 Np->num_curr < Np->out_pre_spaces &&
                 Np->Num->zero_start <= Np->num_curr)
        {
            /*
             * Write ZERO
             */
            *Np->inout_p = '0'; /* Write '0' */
            ++Np->inout_p;
            Np->num_in = true;
        }
        else
        {
            /*
             * Write Decimal point
             */
            if (*Np->number_p == '.')
            {
                if (!Np->last_relevant || *Np->last_relevant != '.')
                {
                    strcpy(Np->inout_p, Np->decimal);   /* Write DEC/D */
                    Np->inout_p += strlen(Np->inout_p);
                }
 
                /*
                 * Ora 'n' -- FM9.9 --> 'n.'
                 */
                else if (IS_FILLMODE(Np->Num) &&
                         Np->last_relevant && *Np->last_relevant == '.')
                {
                    strcpy(Np->inout_p, Np->decimal);   /* Write DEC/D */
                    Np->inout_p += strlen(Np->inout_p);
                }
            }
            else
            {
                /*
                 * Write Digits
                 */
                if (Np->last_relevant && Np->number_p > Np->last_relevant &&
                    id != NUM_0)
                    ;
 
                /*
                 * '0.1' -- 9.9 --> '  .1'
                 */
                else if (IS_PREDEC_SPACE(Np))
                {
                    if (!IS_FILLMODE(Np->Num))
                    {
                        *Np->inout_p = ' ';
                        ++Np->inout_p;
                    }
 
                    /*
                     * '0' -- FM9.9 --> '0.'
                     */
                    else if (Np->last_relevant && *Np->last_relevant == '.')
                    {
                        *Np->inout_p = '0';
                        ++Np->inout_p;
                    }
                }
                else
                {
                    *Np->inout_p = *Np->number_p;   /* Write DIGIT */
                    ++Np->inout_p;
                    Np->num_in = true;
                }
            }
            /* do no exceed string length */
            if (*Np->number_p)
                ++Np->number_p;
        }
 
        end = Np->num_count + (Np->out_pre_spaces ? 1 : 0) + (IS_DECIMAL(Np->Num) ? 1 : 0);
 
        if (Np->last_relevant && Np->last_relevant == Np->number_p)
            end = Np->num_curr;
 
        if (Np->num_curr + 1 == end)
        {
            if (Np->sign_wrote == true && IS_BRACKET(Np->Num))
            {
                *Np->inout_p = Np->sign == '+' ? ' ' : '>';
                ++Np->inout_p;
            }
            else if (IS_LSIGN(Np->Num) && Np->Num->lsign == NUM_LSIGN_POST)
            {
                if (Np->sign == '-')
                    strcpy(Np->inout_p, Np->L_negative_sign);
                else
                    strcpy(Np->inout_p, Np->L_positive_sign);
                Np->inout_p += strlen(Np->inout_p);
            }
        }
    }
 
    ++Np->num_curr;
}

References NUMProc::decimal, elog, NUMProc::inout, NUMProc::inout_p, IS_BRACKET, IS_DECIMAL, IS_FILLMODE, IS_LSIGN, IS_PREDEC_SPACE, IS_ROMAN, IS_ZERO, NUMProc::L_negative_sign, NUMProc::L_positive_sign, NUMProc::last_relevant, NUMDesc::lsign, NUMProc::Num, NUM_0, NUM_9, NUMProc::num_count, NUMProc::num_curr, NUM_D, NUM_DEC, NUMProc::num_in, NUM_LSIGN_POST, NUM_LSIGN_PRE, NUMProc::number_p, NUMProc::out_pre_spaces, NUMProc::sign, NUMProc::sign_wrote, and NUMDesc::zero_start.

Referenced by NUM_processor().

NUM_prepare_locale()

static void NUM_prepare_locale ( NUMProc *  Np )

static

Definition at line 5213 of file formatting.c.

{
    if (Np->Num->need_locale)
    {
        struct lconv *lconv;
 
        /*
         * Get locales
         */
        lconv = PGLC_localeconv();
 
        /*
         * Positive / Negative number sign
         */
        if (lconv->negative_sign && *lconv->negative_sign)
            Np->L_negative_sign = lconv->negative_sign;
        else
            Np->L_negative_sign = "-";
 
        if (lconv->positive_sign && *lconv->positive_sign)
            Np->L_positive_sign = lconv->positive_sign;
        else
            Np->L_positive_sign = "+";
 
        /*
         * Number decimal point
         */
        if (lconv->decimal_point && *lconv->decimal_point)
            Np->decimal = lconv->decimal_point;
 
        else
            Np->decimal = ".";
 
        if (!IS_LDECIMAL(Np->Num))
            Np->decimal = ".";
 
        /*
         * Number thousands separator
         *
         * Some locales (e.g. broken glibc pt_BR), have a comma for decimal,
         * but "" for thousands_sep, so we set the thousands_sep too.
         * http://archives.postgresql.org/pgsql-hackers/2007-11/msg00772.php
         */
        if (lconv->thousands_sep && *lconv->thousands_sep)
            Np->L_thousands_sep = lconv->thousands_sep;
        /* Make sure thousands separator doesn't match decimal point symbol. */
        else if (strcmp(Np->decimal, ",") != 0)
            Np->L_thousands_sep = ",";
        else
            Np->L_thousands_sep = ".";
 
        /*
         * Currency symbol
         */
        if (lconv->currency_symbol && *lconv->currency_symbol)
            Np->L_currency_symbol = lconv->currency_symbol;
        else
            Np->L_currency_symbol = " ";
    }
    else
    {
        /*
         * Default values
         */
        Np->L_negative_sign = "-";
        Np->L_positive_sign = "+";
        Np->decimal = ".";
 
        Np->L_thousands_sep = ",";
        Np->L_currency_symbol = " ";
    }
}

References NUMProc::decimal, IS_LDECIMAL, NUMProc::L_currency_symbol, NUMProc::L_negative_sign, NUMProc::L_positive_sign, NUMProc::L_thousands_sep, NUMDesc::need_locale, NUMProc::Num, and PGLC_localeconv().

Referenced by NUM_processor().

NUM_prevent_counter_overflow()

static void NUM_prevent_counter_overflow ( void  )

inlinestatic

Definition at line 4823 of file formatting.c.

{
    if (NUMCounter >= (INT_MAX - 1))
    {
        for (int i = 0; i < n_NUMCache; i++)
            NUMCache[i]->age >>= 1;
        NUMCounter >>= 1;
    }
}

References i, n_NUMCache, NUMCache, and NUMCounter.

Referenced by NUM_cache_getnew(), and NUM_cache_search().

NUM_processor()

static char * NUM_processor ( FormatNode *  node, NUMDesc *  Num, char *  inout, char *  number, size_t  input_len, int  to_char_out_pre_spaces, int  sign, bool  is_to_char, Oid  collid  )

static

Definition at line 5738 of file formatting.c.

{
    FormatNode *n;
    NUMProc     _Np,
               *Np = &_Np;
    const char *pattern;
    size_t      pattern_len;
 
    MemSet(Np, 0, sizeof(NUMProc));
 
    Np->Num = Num;
    Np->is_to_char = is_to_char;
    Np->number = number;
    Np->inout = inout;
    Np->last_relevant = NULL;
    Np->read_post = 0;
    Np->read_pre = 0;
    Np->read_dec = false;
 
    if (Np->Num->zero_start)
        --Np->Num->zero_start;
 
    if (IS_EEEE(Np->Num))
    {
        if (!Np->is_to_char)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("\"EEEE\" not supported for input")));
        return strcpy(inout, number);
    }
 
    /*
     * Sign
     */
    if (is_to_char)
    {
        Np->sign = sign;
 
        /* MI/PL/SG - write sign itself and not in number */
        if (IS_PLUS(Np->Num) || IS_MINUS(Np->Num))
        {
            if (IS_PLUS(Np->Num) && IS_MINUS(Np->Num) == false)
                Np->sign_wrote = false; /* need sign */
            else
                Np->sign_wrote = true;  /* needn't sign */
        }
        else
        {
            if (Np->sign != '-')
            {
                if (IS_FILLMODE(Np->Num))
                    Np->Num->flag &= ~NUM_F_BRACKET;
            }
 
            if (Np->sign == '+' && IS_FILLMODE(Np->Num) && IS_LSIGN(Np->Num) == false)
                Np->sign_wrote = true;  /* needn't sign */
            else
                Np->sign_wrote = false; /* need sign */
 
            if (Np->Num->lsign == NUM_LSIGN_PRE && Np->Num->pre == Np->Num->pre_lsign_num)
                Np->Num->lsign = NUM_LSIGN_POST;
        }
    }
    else
        Np->sign = false;
 
    /*
     * Count
     */
    Np->num_count = Np->Num->post + Np->Num->pre - 1;
 
    if (is_to_char)
    {
        Np->out_pre_spaces = to_char_out_pre_spaces;
 
        if (IS_FILLMODE(Np->Num) && IS_DECIMAL(Np->Num))
        {
            Np->last_relevant = get_last_relevant_decnum(Np->number);
 
            /*
             * If any '0' specifiers are present, make sure we don't strip
             * those digits.  But don't advance last_relevant beyond the last
             * character of the Np->number string, which is a hazard if the
             * number got shortened due to precision limitations.
             */
            if (Np->last_relevant && Np->Num->zero_end > Np->out_pre_spaces)
            {
                size_t      last_zero_pos;
                char       *last_zero;
 
                /* note that Np->number cannot be zero-length here */
                last_zero_pos = strlen(Np->number) - 1;
                last_zero_pos = Min(last_zero_pos,
                                    Np->Num->zero_end - Np->out_pre_spaces);
                last_zero = Np->number + last_zero_pos;
                if (Np->last_relevant < last_zero)
                    Np->last_relevant = last_zero;
            }
        }
 
        if (Np->sign_wrote == false && Np->out_pre_spaces == 0)
            ++Np->num_count;
    }
    else
    {
        Np->out_pre_spaces = 0;
        *Np->number = ' ';      /* sign space */
        *(Np->number + 1) = '\0';
    }
 
    Np->num_in = 0;
    Np->num_curr = 0;
 
#ifdef DEBUG_TO_FROM_CHAR
    elog(DEBUG_elog_output,
         "\n\tSIGN: '%c'\n\tNUM: '%s'\n\tPRE: %d\n\tPOST: %d\n\tNUM_COUNT: %d\n\tNUM_PRE: %d\n\tSIGN_WROTE: %s\n\tZERO: %s\n\tZERO_START: %d\n\tZERO_END: %d\n\tLAST_RELEVANT: %s\n\tBRACKET: %s\n\tPLUS: %s\n\tMINUS: %s\n\tFILLMODE: %s\n\tROMAN: %s\n\tEEEE: %s",
         Np->sign,
         Np->number,
         Np->Num->pre,
         Np->Num->post,
         Np->num_count,
         Np->out_pre_spaces,
         Np->sign_wrote ? "Yes" : "No",
         IS_ZERO(Np->Num) ? "Yes" : "No",
         Np->Num->zero_start,
         Np->Num->zero_end,
         Np->last_relevant ? Np->last_relevant : "<not set>",
         IS_BRACKET(Np->Num) ? "Yes" : "No",
         IS_PLUS(Np->Num) ? "Yes" : "No",
         IS_MINUS(Np->Num) ? "Yes" : "No",
         IS_FILLMODE(Np->Num) ? "Yes" : "No",
         IS_ROMAN(Np->Num) ? "Yes" : "No",
         IS_EEEE(Np->Num) ? "Yes" : "No"
        );
#endif
 
    /*
     * Locale
     */
    NUM_prepare_locale(Np);
 
    /*
     * Processor direct cycle
     */
    if (Np->is_to_char)
        Np->number_p = Np->number;
    else
        Np->number_p = Np->number + 1;  /* first char is space for sign */
 
    for (n = node, Np->inout_p = Np->inout; n->type != NODE_TYPE_END; n++)
    {
        if (!Np->is_to_char)
        {
            /*
             * Check at least one byte remains to be scanned.  (In actions
             * below, must use AMOUNT_TEST if we want to read more bytes than
             * that.)
             */
            if (OVERLOAD_TEST)
                break;
        }
 
        /*
         * Format pictures actions
         */
        if (n->type == NODE_TYPE_ACTION)
        {
            /*
             * Create/read digit/zero/blank/sign/special-case
             *
             * 'NUM_S' note: The locale sign is anchored to number and we
             * read/write it when we work with first or last number
             * (NUM_0/NUM_9).  This is why NUM_S is missing in switch().
             *
             * Notice the "Np->inout_p++" at the bottom of the loop.  This is
             * why most of the actions advance inout_p one less than you might
             * expect.  In cases where we don't want that increment to happen,
             * a switch case ends with "continue" not "break".
             */
            switch (n->key->id)
            {
                case NUM_9:
                case NUM_0:
                case NUM_DEC:
                case NUM_D:
                    if (Np->is_to_char)
                    {
                        NUM_numpart_to_char(Np, n->key->id);
                        continue;   /* for() */
                    }
                    else
                    {
                        NUM_numpart_from_char(Np, n->key->id, input_len);
                        break;  /* switch() case: */
                    }
 
                case NUM_COMMA:
                    if (Np->is_to_char)
                    {
                        if (!Np->num_in)
                        {
                            if (IS_FILLMODE(Np->Num))
                                continue;
                            else
                                *Np->inout_p = ' ';
                        }
                        else
                            *Np->inout_p = ',';
                    }
                    else
                    {
                        if (!Np->num_in)
                        {
                            if (IS_FILLMODE(Np->Num))
                                continue;
                        }
                        if (*Np->inout_p != ',')
                            continue;
                    }
                    break;
 
                case NUM_G:
                    pattern = Np->L_thousands_sep;
                    pattern_len = strlen(pattern);
                    if (Np->is_to_char)
                    {
                        if (!Np->num_in)
                        {
                            if (IS_FILLMODE(Np->Num))
                                continue;
                            else
                            {
                                /* just in case there are MB chars */
                                pattern_len = pg_mbstrlen(pattern);
                                memset(Np->inout_p, ' ', pattern_len);
                                Np->inout_p += pattern_len - 1;
                            }
                        }
                        else
                        {
                            strcpy(Np->inout_p, pattern);
                            Np->inout_p += pattern_len - 1;
                        }
                    }
                    else
                    {
                        if (!Np->num_in)
                        {
                            if (IS_FILLMODE(Np->Num))
                                continue;
                        }
 
                        /*
                         * Because L_thousands_sep typically contains data
                         * characters (either '.' or ','), we can't use
                         * NUM_eat_non_data_chars here.  Instead skip only if
                         * the input matches L_thousands_sep.
                         */
                        if (AMOUNT_TEST(pattern_len) &&
                            strncmp(Np->inout_p, pattern, pattern_len) == 0)
                            Np->inout_p += pattern_len - 1;
                        else
                            continue;
                    }
                    break;
 
                case NUM_L:
                    pattern = Np->L_currency_symbol;
                    if (Np->is_to_char)
                    {
                        strcpy(Np->inout_p, pattern);
                        Np->inout_p += strlen(pattern) - 1;
                    }
                    else
                    {
                        NUM_eat_non_data_chars(Np, pg_mbstrlen(pattern), input_len);
                        continue;
                    }
                    break;
 
                case NUM_RN:
                case NUM_rn:
                    if (Np->is_to_char)
                    {
                        const char *number_p;
 
                        if (n->key->id == NUM_rn)
                            number_p = asc_tolower_z(Np->number_p);
                        else
                            number_p = Np->number_p;
                        if (IS_FILLMODE(Np->Num))
                            strcpy(Np->inout_p, number_p);
                        else
                            sprintf(Np->inout_p, "%15s", number_p);
                        Np->inout_p += strlen(Np->inout_p) - 1;
                    }
                    else
                    {
                        int         roman_result = roman_to_int(Np, input_len);
                        int         numlen;
 
                        if (roman_result < 0)
                            ereport(ERROR,
                                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                                     errmsg("invalid Roman numeral")));
                        numlen = sprintf(Np->number_p, "%d", roman_result);
                        Np->number_p += numlen;
                        Np->Num->pre = numlen;
                        Np->Num->post = 0;
                        continue;   /* roman_to_int ate all the chars */
                    }
                    break;
 
                case NUM_th:
                    if (IS_ROMAN(Np->Num) || *Np->number == '#' ||
                        Np->sign == '-' || IS_DECIMAL(Np->Num))
                        continue;
 
                    if (Np->is_to_char)
                    {
                        strcpy(Np->inout_p, get_th(Np->number, TH_LOWER));
                        Np->inout_p += 1;
                    }
                    else
                    {
                        /* All variants of 'th' occupy 2 characters */
                        NUM_eat_non_data_chars(Np, 2, input_len);
                        continue;
                    }
                    break;
 
                case NUM_TH:
                    if (IS_ROMAN(Np->Num) || *Np->number == '#' ||
                        Np->sign == '-' || IS_DECIMAL(Np->Num))
                        continue;
 
                    if (Np->is_to_char)
                    {
                        strcpy(Np->inout_p, get_th(Np->number, TH_UPPER));
                        Np->inout_p += 1;
                    }
                    else
                    {
                        /* All variants of 'TH' occupy 2 characters */
                        NUM_eat_non_data_chars(Np, 2, input_len);
                        continue;
                    }
                    break;
 
                case NUM_MI:
                    if (Np->is_to_char)
                    {
                        if (Np->sign == '-')
                            *Np->inout_p = '-';
                        else if (IS_FILLMODE(Np->Num))
                            continue;
                        else
                            *Np->inout_p = ' ';
                    }
                    else
                    {
                        if (*Np->inout_p == '-')
                            *Np->number = '-';
                        else
                        {
                            NUM_eat_non_data_chars(Np, 1, input_len);
                            continue;
                        }
                    }
                    break;
 
                case NUM_PL:
                    if (Np->is_to_char)
                    {
                        if (Np->sign == '+')
                            *Np->inout_p = '+';
                        else if (IS_FILLMODE(Np->Num))
                            continue;
                        else
                            *Np->inout_p = ' ';
                    }
                    else
                    {
                        if (*Np->inout_p == '+')
                            *Np->number = '+';
                        else
                        {
                            NUM_eat_non_data_chars(Np, 1, input_len);
                            continue;
                        }
                    }
                    break;
 
                case NUM_SG:
                    if (Np->is_to_char)
                        *Np->inout_p = Np->sign;
                    else
                    {
                        if (*Np->inout_p == '-')
                            *Np->number = '-';
                        else if (*Np->inout_p == '+')
                            *Np->number = '+';
                        else
                        {
                            NUM_eat_non_data_chars(Np, 1, input_len);
                            continue;
                        }
                    }
                    break;
 
                default:
                    continue;
                    break;
            }
        }
        else
        {
            /*
             * In TO_CHAR, non-pattern characters in the format are copied to
             * the output.  In TO_NUMBER, we skip one input character for each
             * non-pattern format character, whether or not it matches the
             * format character.
             */
            if (Np->is_to_char)
            {
                strcpy(Np->inout_p, n->character);
                Np->inout_p += strlen(Np->inout_p);
            }
            else
            {
                Np->inout_p += pg_mblen(Np->inout_p);
            }
            continue;
        }
        Np->inout_p++;
    }
 
    if (Np->is_to_char)
    {
        *Np->inout_p = '\0';
        return Np->inout;
    }
    else
    {
        if (*(Np->number_p - 1) == '.')
            *(Np->number_p - 1) = '\0';
        else
            *Np->number_p = '\0';
 
        /*
         * Correction - precision of dec. number
         */
        Np->Num->post = Np->read_post;
 
#ifdef DEBUG_TO_FROM_CHAR
        elog(DEBUG_elog_output, "TO_NUMBER (number): '%s'", Np->number);
#endif
        return Np->number;
    }
}

References AMOUNT_TEST, asc_tolower_z(), FormatNode::character, elog, ereport, errcode(), errmsg(), ERROR, NUMDesc::flag, get_last_relevant_decnum(), get_th(), KeyWord::id, NUMProc::inout, NUMProc::inout_p, IS_BRACKET, IS_DECIMAL, IS_EEEE, IS_FILLMODE, IS_LSIGN, IS_MINUS, IS_PLUS, IS_ROMAN, NUMProc::is_to_char, IS_ZERO, FormatNode::key, NUMProc::L_currency_symbol, NUMProc::L_thousands_sep, NUMProc::last_relevant, NUMDesc::lsign, MemSet, Min, NODE_TYPE_ACTION, NODE_TYPE_END, NUMProc::Num, NUM_0, NUM_9, NUM_COMMA, NUMProc::num_count, NUMProc::num_curr, NUM_D, NUM_DEC, NUM_eat_non_data_chars(), NUM_G, NUMProc::num_in, NUM_L, NUM_LSIGN_POST, NUM_LSIGN_PRE, NUM_MI, NUM_numpart_from_char(), NUM_numpart_to_char(), NUM_PL, NUM_prepare_locale(), NUM_RN, NUM_rn, NUM_SG, NUM_TH, NUM_th, NUMProc::number, NUMProc::number_p, NUMProc::out_pre_spaces, OVERLOAD_TEST, pg_mblen(), pg_mbstrlen(), NUMDesc::post, NUMDesc::pre, NUMDesc::pre_lsign_num, NUMProc::read_dec, NUMProc::read_post, NUMProc::read_pre, roman_to_int(), NUMProc::sign, sign, NUMProc::sign_wrote, sprintf, TH_LOWER, TH_UPPER, FormatNode::type, NUMDesc::zero_end, and NUMDesc::zero_start.

Referenced by numeric_to_number().

NUMDesc_prepare()

static void NUMDesc_prepare ( NUMDesc *  num, FormatNode *  n  )

static

Definition at line 1185 of file formatting.c.

{
    if (n->type != NODE_TYPE_ACTION)
        return;
 
    if (IS_EEEE(num) && n->key->id != NUM_E)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("\"EEEE\" must be the last pattern used")));
 
    switch (n->key->id)
    {
        case NUM_9:
            if (IS_BRACKET(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("\"9\" must be ahead of \"PR\"")));
            if (IS_MULTI(num))
            {
                ++num->multi;
                break;
            }
            if (IS_DECIMAL(num))
                ++num->post;
            else
                ++num->pre;
            break;
 
        case NUM_0:
            if (IS_BRACKET(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("\"0\" must be ahead of \"PR\"")));
            if (!IS_ZERO(num) && !IS_DECIMAL(num))
            {
                num->flag |= NUM_F_ZERO;
                num->zero_start = num->pre + 1;
            }
            if (!IS_DECIMAL(num))
                ++num->pre;
            else
                ++num->post;
 
            num->zero_end = num->pre + num->post;
            break;
 
        case NUM_B:
            if (num->pre == 0 && num->post == 0 && !IS_ZERO(num))
                num->flag |= NUM_F_BLANK;
            break;
 
        case NUM_D:
            num->flag |= NUM_F_LDECIMAL;
            num->need_locale = true;
            /* FALLTHROUGH */
        case NUM_DEC:
            if (IS_DECIMAL(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("multiple decimal points")));
            if (IS_MULTI(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"V\" and decimal point together")));
            num->flag |= NUM_F_DECIMAL;
            break;
 
        case NUM_FM:
            num->flag |= NUM_F_FILLMODE;
            break;
 
        case NUM_S:
            if (IS_LSIGN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"S\" twice")));
            if (IS_PLUS(num) || IS_MINUS(num) || IS_BRACKET(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"S\" and \"PL\"/\"MI\"/\"SG\"/\"PR\" together")));
            if (!IS_DECIMAL(num))
            {
                num->lsign = NUM_LSIGN_PRE;
                num->pre_lsign_num = num->pre;
                num->need_locale = true;
                num->flag |= NUM_F_LSIGN;
            }
            else if (num->lsign == NUM_LSIGN_NONE)
            {
                num->lsign = NUM_LSIGN_POST;
                num->need_locale = true;
                num->flag |= NUM_F_LSIGN;
            }
            break;
 
        case NUM_MI:
            if (IS_LSIGN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"S\" and \"MI\" together")));
            num->flag |= NUM_F_MINUS;
            if (IS_DECIMAL(num))
                num->flag |= NUM_F_MINUS_POST;
            break;
 
        case NUM_PL:
            if (IS_LSIGN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"S\" and \"PL\" together")));
            num->flag |= NUM_F_PLUS;
            if (IS_DECIMAL(num))
                num->flag |= NUM_F_PLUS_POST;
            break;
 
        case NUM_SG:
            if (IS_LSIGN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"S\" and \"SG\" together")));
            num->flag |= NUM_F_MINUS;
            num->flag |= NUM_F_PLUS;
            break;
 
        case NUM_PR:
            if (IS_LSIGN(num) || IS_PLUS(num) || IS_MINUS(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"PR\" and \"S\"/\"PL\"/\"MI\"/\"SG\" together")));
            num->flag |= NUM_F_BRACKET;
            break;
 
        case NUM_rn:
        case NUM_RN:
            if (IS_ROMAN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"RN\" twice")));
            num->flag |= NUM_F_ROMAN;
            break;
 
        case NUM_L:
        case NUM_G:
            num->need_locale = true;
            break;
 
        case NUM_V:
            if (IS_DECIMAL(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"V\" and decimal point together")));
            num->flag |= NUM_F_MULTI;
            break;
 
        case NUM_E:
            if (IS_EEEE(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("cannot use \"EEEE\" twice")));
            if (IS_BLANK(num) || IS_FILLMODE(num) || IS_LSIGN(num) ||
                IS_BRACKET(num) || IS_MINUS(num) || IS_PLUS(num) ||
                IS_ROMAN(num) || IS_MULTI(num))
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("\"EEEE\" is incompatible with other formats"),
                         errdetail("\"EEEE\" may only be used together with digit and decimal point patterns.")));
            num->flag |= NUM_F_EEEE;
            break;
    }
 
    if (IS_ROMAN(num) &&
        (num->flag & ~(NUM_F_ROMAN | NUM_F_FILLMODE)) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("\"RN\" is incompatible with other formats"),
                 errdetail("\"RN\" may only be used together with \"FM\".")));
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, NUMDesc::flag, KeyWord::id, IS_BLANK, IS_BRACKET, IS_DECIMAL, IS_EEEE, IS_FILLMODE, IS_LSIGN, IS_MINUS, IS_MULTI, IS_PLUS, IS_ROMAN, IS_ZERO, FormatNode::key, NUMDesc::lsign, NUMDesc::multi, NUMDesc::need_locale, NODE_TYPE_ACTION, NUM_0, NUM_9, NUM_B, NUM_D, NUM_DEC, NUM_E, NUM_F_BLANK, NUM_F_BRACKET, NUM_F_DECIMAL, NUM_F_EEEE, NUM_F_FILLMODE, NUM_F_LDECIMAL, NUM_F_LSIGN, NUM_F_MINUS, NUM_F_MINUS_POST, NUM_F_MULTI, NUM_F_PLUS, NUM_F_PLUS_POST, NUM_F_ROMAN, NUM_F_ZERO, NUM_FM, NUM_G, NUM_L, NUM_LSIGN_NONE, NUM_LSIGN_POST, NUM_LSIGN_PRE, NUM_MI, NUM_PL, NUM_PR, NUM_RN, NUM_rn, NUM_S, NUM_SG, NUM_V, NUMDesc::post, NUMDesc::pre, NUMDesc::pre_lsign_num, FormatNode::type, NUMDesc::zero_end, and NUMDesc::zero_start.

Referenced by parse_format().

numeric_to_char()

Datum numeric_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 6293 of file formatting.c.

{
    Numeric     value = PG_GETARG_NUMERIC(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    NUMDesc     Num;
    FormatNode *format;
    text       *result;
    bool        shouldFree;
    int         out_pre_spaces = 0,
                sign = 0;
    char       *numstr,
               *orgnum,
               *p;
 
    NUM_TOCHAR_prepare;
 
    /*
     * On DateType depend part (numeric)
     */
    if (IS_ROMAN(&Num))
    {
        int32       intvalue;
        ErrorSaveContext escontext = {T_ErrorSaveContext};
 
        /* Round and convert to int */
        intvalue = numeric_int4_safe(value, (Node *) &escontext);
        /* On overflow, just use PG_INT32_MAX; int_to_roman will cope */
        if (escontext.error_occurred)
            intvalue = PG_INT32_MAX;
        numstr = int_to_roman(intvalue);
    }
    else if (IS_EEEE(&Num))
    {
        orgnum = numeric_out_sci(value, Num.post);
 
        /*
         * numeric_out_sci() does not emit a sign for positive numbers.  We
         * need to add a space in this case so that positive and negative
         * numbers are aligned.  Also must check for NaN/infinity cases, which
         * we handle the same way as in float8_to_char.
         */
        if (strcmp(orgnum, "NaN") == 0 ||
            strcmp(orgnum, "Infinity") == 0 ||
            strcmp(orgnum, "-Infinity") == 0)
        {
            /*
             * Allow 6 characters for the leading sign, the decimal point,
             * "e", the exponent's sign and two exponent digits.
             */
            numstr = (char *) palloc(Num.pre + Num.post + 7);
            fill_str(numstr, '#', Num.pre + Num.post + 6);
            *numstr = ' ';
            *(numstr + Num.pre + 1) = '.';
        }
        else if (*orgnum != '-')
        {
            numstr = (char *) palloc(strlen(orgnum) + 2);
            *numstr = ' ';
            strcpy(numstr + 1, orgnum);
        }
        else
        {
            numstr = orgnum;
        }
    }
    else
    {
        size_t      numstr_pre_len;
        Numeric     val = value;
        Numeric     x;
 
        if (IS_MULTI(&Num))
        {
            Numeric     a = int64_to_numeric(10);
            Numeric     b = int64_to_numeric(Num.multi);
 
            x = DatumGetNumeric(DirectFunctionCall2(numeric_power,
                                                    NumericGetDatum(a),
                                                    NumericGetDatum(b)));
            val = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
                                                      NumericGetDatum(value),
                                                      NumericGetDatum(x)));
            Num.pre += Num.multi;
        }
 
        x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
                                                NumericGetDatum(val),
                                                Int32GetDatum(Num.post)));
        orgnum = DatumGetCString(DirectFunctionCall1(numeric_out,
                                                     NumericGetDatum(x)));
 
        if (*orgnum == '-')
        {
            sign = '-';
            numstr = orgnum + 1;
        }
        else
        {
            sign = '+';
            numstr = orgnum;
        }
 
        if ((p = strchr(numstr, '.')))
            numstr_pre_len = p - numstr;
        else
            numstr_pre_len = strlen(numstr);
 
        /* needs padding? */
        if (numstr_pre_len < Num.pre)
            out_pre_spaces = Num.pre - numstr_pre_len;
        /* overflowed prefix digit format? */
        else if (numstr_pre_len > Num.pre)
        {
            numstr = (char *) palloc(Num.pre + Num.post + 2);
            fill_str(numstr, '#', Num.pre + Num.post + 1);
            *(numstr + Num.pre) = '.';
        }
    }

References a, b, DatumGetCString(), DatumGetNumeric(), DirectFunctionCall1, DirectFunctionCall2, ErrorSaveContext::error_occurred, fill_str(), format, Int32GetDatum(), int64_to_numeric(), int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, numeric_int4_safe(), numeric_mul(), numeric_out(), numeric_out_sci(), numeric_power(), numeric_round(), NumericGetDatum(), palloc(), PG_GETARG_NUMERIC, PG_GETARG_TEXT_PP, PG_INT32_MAX, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, sign, val, value, and x.

numeric_to_number()

Datum numeric_to_number

(

PG_FUNCTION_ARGS

)

Definition at line 6235 of file formatting.c.

{
    text       *value = PG_GETARG_TEXT_PP(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    NUMDesc     Num;
    Datum       result;
    FormatNode *format;
    char       *numstr;
    bool        shouldFree;
    int         len = 0;
    int         scale,
                precision;
 
    len = VARSIZE_ANY_EXHDR(fmt);
 
    if (len <= 0 || len >= INT_MAX / NUM_MAX_ITEM_SIZ)
        PG_RETURN_NULL();
 
    format = NUM_cache(len, &Num, fmt, &shouldFree);
 
    numstr = (char *) palloc((len * NUM_MAX_ITEM_SIZ) + 1);
 
    NUM_processor(format, &Num, VARDATA_ANY(value), numstr,
                  VARSIZE_ANY_EXHDR(value), 0, 0, false, PG_GET_COLLATION());
 
    scale = Num.post;
    precision = Num.pre + Num.multi + scale;
 
    if (shouldFree)
        pfree(format);
 
    result = DirectFunctionCall3(numeric_in,
                                 CStringGetDatum(numstr),
                                 ObjectIdGetDatum(InvalidOid),
                                 Int32GetDatum(((precision << 16) | scale) + VARHDRSZ));
 
    if (IS_MULTI(&Num))
    {
        Numeric     x;
        Numeric     a = int64_to_numeric(10);
        Numeric     b = int64_to_numeric(-Num.multi);
 
        x = DatumGetNumeric(DirectFunctionCall2(numeric_power,
                                                NumericGetDatum(a),
                                                NumericGetDatum(b)));
        result = DirectFunctionCall2(numeric_mul,
                                     result,
                                     NumericGetDatum(x));
    }

References a, b, CStringGetDatum(), DatumGetNumeric(), DirectFunctionCall2, DirectFunctionCall3, format, Int32GetDatum(), int64_to_numeric(), InvalidOid, IS_MULTI, len, NUMDesc::multi, NUM_cache(), NUM_MAX_ITEM_SIZ, NUM_processor(), numeric_in(), numeric_mul(), numeric_power(), NumericGetDatum(), ObjectIdGetDatum(), palloc(), pfree(), PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_NULL, NUMDesc::post, NUMDesc::pre, scale, value, VARDATA_ANY(), VARHDRSZ, VARSIZE_ANY_EXHDR(), and x.

parse_datetime()

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

Definition at line 4156 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_object(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_object, 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().

parse_format()

static void parse_format ( FormatNode *  node, const char *  str, const KeyWord *  kw, const KeySuffix *  suf, const int *  index, uint32  flags, NUMDesc *  Num  )

static

Definition at line 1370 of file formatting.c.

{
    FormatNode *n;
 
#ifdef DEBUG_TO_FROM_CHAR
    elog(DEBUG_elog_output, "to_char/number(): run parser");
#endif
 
    n = node;
 
    while (*str)
    {
        int         suffix = 0;
        const KeySuffix *s;
 
        /*
         * Prefix
         */
        if ((flags & DCH_FLAG) &&
            (s = suff_search(str, suf, SUFFTYPE_PREFIX)) != NULL)
        {
            suffix |= s->id;
            if (s->len)
                str += s->len;
        }
 
        /*
         * Keyword
         */
        if (*str && (n->key = index_seq_search(str, kw, index)) != NULL)
        {
            n->type = NODE_TYPE_ACTION;
            n->suffix = suffix;
            if (n->key->len)
                str += n->key->len;
 
            /*
             * NUM version: Prepare global NUMDesc struct
             */
            if (flags & NUM_FLAG)
                NUMDesc_prepare(Num, n);
 
            /*
             * Postfix
             */
            if ((flags & DCH_FLAG) && *str &&
                (s = suff_search(str, suf, SUFFTYPE_POSTFIX)) != NULL)
            {
                n->suffix |= s->id;
                if (s->len)
                    str += s->len;
            }
 
            n++;
        }
        else if (*str)
        {
            int         chlen;
 
            if ((flags & STD_FLAG) && *str != '"')
            {
                /*
                 * Standard mode, allow only following separators: "-./,':; ".
                 * However, we support double quotes even in standard mode
                 * (see below).  This is our extension of standard mode.
                 */
                if (strchr("-./,':; ", *str) == NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                             errmsg("invalid datetime format separator: \"%s\"",
                                    pnstrdup(str, pg_mblen(str)))));
 
                if (*str == ' ')
                    n->type = NODE_TYPE_SPACE;
                else
                    n->type = NODE_TYPE_SEPARATOR;
 
                n->character[0] = *str;
                n->character[1] = '\0';
                n->key = NULL;
                n->suffix = 0;
                n++;
                str++;
            }
            else if (*str == '"')
            {
                /*
                 * Process double-quoted literal string, if any
                 */
                str++;
                while (*str)
                {
                    if (*str == '"')
                    {
                        str++;
                        break;
                    }
                    /* backslash quotes the next character, if any */
                    if (*str == '\\' && *(str + 1))
                        str++;
                    chlen = pg_mblen(str);
                    n->type = NODE_TYPE_CHAR;
                    memcpy(n->character, str, chlen);
                    n->character[chlen] = '\0';
                    n->key = NULL;
                    n->suffix = 0;
                    n++;
                    str += chlen;
                }
            }
            else
            {
                /*
                 * Outside double-quoted strings, backslash is only special if
                 * it immediately precedes a double quote.
                 */
                if (*str == '\\' && *(str + 1) == '"')
                    str++;
                chlen = pg_mblen(str);
 
                if ((flags & DCH_FLAG) && is_separator_char(str))
                    n->type = NODE_TYPE_SEPARATOR;
                else if (isspace((unsigned char) *str))
                    n->type = NODE_TYPE_SPACE;
                else
                    n->type = NODE_TYPE_CHAR;
 
                memcpy(n->character, str, chlen);
                n->character[chlen] = '\0';
                n->key = NULL;
                n->suffix = 0;
                n++;
                str += chlen;
            }
        }
    }
 
    n->type = NODE_TYPE_END;
    n->suffix = 0;
}

References FormatNode::character, DCH_FLAG, elog, ereport, errcode(), errmsg(), ERROR, KeySuffix::id, index_seq_search(), is_separator_char(), FormatNode::key, KeySuffix::len, KeyWord::len, NODE_TYPE_ACTION, NODE_TYPE_CHAR, NODE_TYPE_END, NODE_TYPE_SEPARATOR, NODE_TYPE_SPACE, NUM_FLAG, NUMDesc_prepare(), pg_mblen(), pnstrdup(), STD_FLAG, str, suff_search(), FormatNode::suffix, SUFFTYPE_POSTFIX, SUFFTYPE_PREFIX, and FormatNode::type.

Referenced by datetime_format_has_tz(), datetime_to_char_body(), DCH_cache_fetch(), do_to_timestamp(), NUM_cache(), and NUM_cache_fetch().

roman_to_int()

static int roman_to_int ( NUMProc *  Np, size_t  input_len  )

static

Definition at line 5064 of file formatting.c.

{
    int         result = 0;
    size_t      len;
    char        romanChars[MAX_ROMAN_LEN];
    int         romanValues[MAX_ROMAN_LEN];
    int         repeatCount = 1;
    int         vCount = 0,
                lCount = 0,
                dCount = 0;
    bool        subtractionEncountered = false;
    int         lastSubtractedValue = 0;
 
    /*
     * Skip any leading whitespace.  Perhaps we should limit the amount of
     * space skipped to MAX_ROMAN_LEN, but that seems unnecessarily picky.
     */
    while (!OVERLOAD_TEST && isspace((unsigned char) *Np->inout_p))
        Np->inout_p++;
 
    /*
     * Collect and decode valid roman numerals, consuming at most
     * MAX_ROMAN_LEN characters.  We do this in a separate loop to avoid
     * repeated decoding and because the main loop needs to know when it's at
     * the last numeral.
     */
    for (len = 0; len < MAX_ROMAN_LEN && !OVERLOAD_TEST; len++)
    {
        char        currChar = pg_ascii_toupper(*Np->inout_p);
        int         currValue = ROMAN_VAL(currChar);
 
        if (currValue == 0)
            break;              /* Not a valid roman numeral. */
        romanChars[len] = currChar;
        romanValues[len] = currValue;
        Np->inout_p++;
    }
 
    if (len == 0)
        return -1;              /* No valid roman numerals. */
 
    /* Check for valid combinations and compute the represented value. */
    for (size_t i = 0; i < len; i++)
    {
        char        currChar = romanChars[i];
        int         currValue = romanValues[i];
 
        /*
         * Ensure no numeral greater than or equal to the subtracted numeral
         * appears after a subtraction.
         */
        if (subtractionEncountered && currValue >= lastSubtractedValue)
            return -1;
 
        /*
         * V, L, and D should not appear before a larger numeral, nor should
         * they be repeated.
         */
        if ((vCount && currValue >= ROMAN_VAL('V')) ||
            (lCount && currValue >= ROMAN_VAL('L')) ||
            (dCount && currValue >= ROMAN_VAL('D')))
            return -1;
        if (currChar == 'V')
            vCount++;
        else if (currChar == 'L')
            lCount++;
        else if (currChar == 'D')
            dCount++;
 
        if (i < len - 1)
        {
            /* Compare current numeral to next numeral. */
            char        nextChar = romanChars[i + 1];
            int         nextValue = romanValues[i + 1];
 
            /*
             * If the current value is less than the next value, handle
             * subtraction. Verify valid subtractive combinations and update
             * the result accordingly.
             */
            if (currValue < nextValue)
            {
                if (!IS_VALID_SUB_COMB(currChar, nextChar))
                    return -1;
 
                /*
                 * Reject cases where same numeral is repeated with
                 * subtraction (e.g. 'MCCM' or 'DCCCD').
                 */
                if (repeatCount > 1)
                    return -1;
 
                /*
                 * We are going to skip nextChar, so first make checks needed
                 * for V, L, and D.  These are the same as we'd have applied
                 * if we reached nextChar without a subtraction.
                 */
                if ((vCount && nextValue >= ROMAN_VAL('V')) ||
                    (lCount && nextValue >= ROMAN_VAL('L')) ||
                    (dCount && nextValue >= ROMAN_VAL('D')))
                    return -1;
                if (nextChar == 'V')
                    vCount++;
                else if (nextChar == 'L')
                    lCount++;
                else if (nextChar == 'D')
                    dCount++;
 
                /*
                 * Skip the next numeral as it is part of the subtractive
                 * combination.
                 */
                i++;
 
                /* Update state. */
                repeatCount = 1;
                subtractionEncountered = true;
                lastSubtractedValue = currValue;
                result += (nextValue - currValue);
            }
            else
            {
                /* For same numerals, check for repetition. */
                if (currChar == nextChar)
                {
                    repeatCount++;
                    if (repeatCount > 3)
                        return -1;
                }
                else
                    repeatCount = 1;
                result += currValue;
            }
        }
        else
        {
            /* This is the last numeral; just add it to the result. */
            result += currValue;
        }
    }
 
    return result;
}

References i, NUMProc::inout_p, IS_VALID_SUB_COMB, len, MAX_ROMAN_LEN, OVERLOAD_TEST, pg_ascii_toupper(), and ROMAN_VAL.

Referenced by NUM_processor().

seq_search_ascii()

static int seq_search_ascii ( const char *  name, const char *const *  array, size_t *  len  )

static

Definition at line 2289 of file formatting.c.

{
    unsigned char firstc;
 
    *len = 0;
 
    /* empty string can't match anything */
    if (!*name)
        return -1;
 
    /* we handle first char specially to gain some speed */
    firstc = pg_ascii_tolower((unsigned char) *name);
 
    for (const char *const *a = array; *a != NULL; a++)
    {
        /* compare first chars */
        if (pg_ascii_tolower((unsigned char) **a) != firstc)
            continue;
 
        /* compare rest of string */
        for (const char *p = *a + 1, *n = name + 1;; p++, n++)
        {
            /* return success if we matched whole array entry */
            if (*p == '\0')
            {
                *len = n - name;
                return a - array;
            }
            /* else, must have another character in "name" ... */
            if (*n == '\0')
                break;
            /* ... and it must match */
            if (pg_ascii_tolower((unsigned char) *p) !=
                pg_ascii_tolower((unsigned char) *n))
                break;
        }
    }
 
    return -1;
}

References a, len, name, and pg_ascii_tolower().

Referenced by from_char_seq_search().

seq_search_localized()

static int seq_search_localized ( const char *  name, char **  array, size_t *  len, Oid  collid  )

static

Definition at line 2342 of file formatting.c.

{
    char       *upper_name;
    char       *lower_name;
 
    *len = 0;
 
    /* empty string can't match anything */
    if (!*name)
        return -1;
 
    /*
     * The case-folding processing done below is fairly expensive, so before
     * doing that, make a quick pass to see if there is an exact match.
     */
    for (char **a = array; *a != NULL; a++)
    {
        size_t      element_len = strlen(*a);
 
        if (strncmp(name, *a, element_len) == 0)
        {
            *len = element_len;
            return a - array;
        }
    }
 
    /*
     * Fold to upper case, then to lower case, so that we can match reliably
     * even in languages in which case conversions are not injective.
     */
    upper_name = str_toupper(name, strlen(name), collid);
    lower_name = str_tolower(upper_name, strlen(upper_name), collid);
    pfree(upper_name);
 
    for (char **a = array; *a != NULL; a++)
    {
        char       *upper_element;
        char       *lower_element;
        size_t      element_len;
 
        /* Likewise upper/lower-case array element */
        upper_element = str_toupper(*a, strlen(*a), collid);
        lower_element = str_tolower(upper_element, strlen(upper_element),
                                    collid);
        pfree(upper_element);
        element_len = strlen(lower_element);
 
        /* Match? */
        if (strncmp(lower_name, lower_element, element_len) == 0)
        {
            *len = element_len;
            pfree(lower_element);
            pfree(lower_name);
            return a - array;
        }
        pfree(lower_element);
    }
 
    pfree(lower_name);
    return -1;
}

References a, collid, len, name, pfree(), str_tolower(), and str_toupper().

Referenced by from_char_seq_search().

str_casefold()

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

Definition at line 1811 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 1747 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_initcap_z()

static char * str_initcap_z ( const char *  buff, Oid  collid  )

static

Definition at line 1966 of file formatting.c.

{
    return str_initcap(buff, strlen(buff), collid);
}

References collid, and str_initcap().

Referenced by DCH_to_char().

str_numth()

static char * str_numth ( char *  dest, const char *  num, enum TH_Case  type  )

static

Definition at line 1600 of file formatting.c.

{
    if (dest != num)
        strcpy(dest, num);
    strcat(dest, get_th(num, type));
    return dest;
}

References generate_unaccent_rules::dest, get_th(), and type.

Referenced by DCH_to_char().

str_tolower()

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

Definition at line 1619 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(), NIImportAffixes(), read_dictionary(), seq_search_localized(), and str_tolower_z().

str_tolower_z()

static char * str_tolower_z ( const char *  buff, Oid  collid  )

static

Definition at line 1954 of file formatting.c.

{
    return str_tolower(buff, strlen(buff), collid);
}

References collid, and str_tolower().

Referenced by DCH_to_char().

str_toupper()

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

Definition at line 1683 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().

str_toupper_z()

static char * str_toupper_z ( const char *  buff, Oid  collid  )

static

Definition at line 1960 of file formatting.c.

{
    return str_toupper(buff, strlen(buff), collid);
}

References collid, and str_toupper().

Referenced by DCH_to_char().

strspace_len()

static size_t strspace_len ( const char *  str )

static

Definition at line 2093 of file formatting.c.

{
    size_t      len = 0;
 
    while (*str && isspace((unsigned char) *str))
    {
        str++;
        len++;
    }
    return len;
}

References len, and str.

Referenced by from_char_parse_int_len().

suff_search()

static const KeySuffix * suff_search ( const char *  str, const KeySuffix *  suf, enum KeySuffixType  type  )

static

Definition at line 1158 of file formatting.c.

{
    for (const KeySuffix *s = suf; s->name != NULL; s++)
    {
        if (s->type != type)
            continue;
 
        if (strncmp(str, s->name, s->len) == 0)
            return s;
    }
    return NULL;
}

References KeySuffix::name, str, and type.

Referenced by parse_format().

SUFFIX_TH_TYPE()

static enum TH_Case SUFFIX_TH_TYPE ( uint8  _s )

inlinestatic

Definition at line 578 of file formatting.c.

{
    return _s & DCH_SUFFIX_TH ? TH_UPPER : TH_LOWER;
}

References DCH_SUFFIX_TH, TH_LOWER, and TH_UPPER.

Referenced by DCH_to_char().

timestamp_to_char()

Datum timestamp_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 3956 of file formatting.c.

{
    Timestamp   dt = PG_GETARG_TIMESTAMP(0);
    text       *fmt = PG_GETARG_TEXT_PP(1),
               *res;
    TmToChar    tmtc;
    struct pg_tm tt;
    struct fmt_tm *tm;
    int         thisdate;
 
    if (VARSIZE_ANY_EXHDR(fmt) <= 0 || TIMESTAMP_NOT_FINITE(dt))
        PG_RETURN_NULL();
 
    ZERO_tmtc(&tmtc);
    tm = tmtcTm(&tmtc);
 
    if (timestamp2tm(dt, NULL, &tt, &tmtcFsec(&tmtc), NULL, NULL) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    /* calculate wday and yday, because timestamp2tm doesn't */
    thisdate = date2j(tt.tm_year, tt.tm_mon, tt.tm_mday);
    tt.tm_wday = (thisdate + 1) % 7;
    tt.tm_yday = thisdate - date2j(tt.tm_year, 1, 1) + 1;
 
    COPY_tm(tm, &tt);
 
    if (!(res = datetime_to_char_body(&tmtc, fmt, false, PG_GET_COLLATION())))
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(res);
}

References COPY_tm, date2j(), datetime_to_char_body(), ereport, errcode(), errmsg(), ERROR, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMP, PG_RETURN_NULL, PG_RETURN_TEXT_P, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_wday, pg_tm::tm_yday, pg_tm::tm_year, tmtcFsec, tmtcTm, VARSIZE_ANY_EXHDR(), and ZERO_tmtc.

timestamptz_to_char()

Datum timestamptz_to_char

(

PG_FUNCTION_ARGS

)

Definition at line 3991 of file formatting.c.

{
    TimestampTz dt = PG_GETARG_TIMESTAMP(0);
    text       *fmt = PG_GETARG_TEXT_PP(1),
               *res;
    TmToChar    tmtc;
    int         tz;
    struct pg_tm tt;
    struct fmt_tm *tm;
    int         thisdate;
 
    if (VARSIZE_ANY_EXHDR(fmt) <= 0 || TIMESTAMP_NOT_FINITE(dt))
        PG_RETURN_NULL();
 
    ZERO_tmtc(&tmtc);
    tm = tmtcTm(&tmtc);
 
    if (timestamp2tm(dt, &tz, &tt, &tmtcFsec(&tmtc), &tmtcTzn(&tmtc), NULL) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    /* calculate wday and yday, because timestamp2tm doesn't */
    thisdate = date2j(tt.tm_year, tt.tm_mon, tt.tm_mday);
    tt.tm_wday = (thisdate + 1) % 7;
    tt.tm_yday = thisdate - date2j(tt.tm_year, 1, 1) + 1;
 
    COPY_tm(tm, &tt);
 
    if (!(res = datetime_to_char_body(&tmtc, fmt, false, PG_GET_COLLATION())))
        PG_RETURN_NULL();
 
    PG_RETURN_TEXT_P(res);
}

References COPY_tm, date2j(), datetime_to_char_body(), ereport, errcode(), errmsg(), ERROR, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_GETARG_TIMESTAMP, PG_RETURN_NULL, PG_RETURN_TEXT_P, timestamp2tm(), TIMESTAMP_NOT_FINITE, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_wday, pg_tm::tm_yday, pg_tm::tm_year, tmtcFsec, tmtcTm, tmtcTzn, VARSIZE_ANY_EXHDR(), and ZERO_tmtc.

to_date()

Datum to_date

(

PG_FUNCTION_ARGS

)

Definition at line 4110 of file formatting.c.

{
    text       *date_txt = PG_GETARG_TEXT_PP(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    Oid         collid = PG_GET_COLLATION();
    DateADT     result;
    struct pg_tm tm;
    struct fmt_tz ftz;
    fsec_t      fsec;
 
    do_to_timestamp(date_txt, fmt, collid, false,
                    &tm, &fsec, &ftz, NULL, NULL, NULL);
 
    /* Prevent overflow in Julian-day routines */
    if (!IS_VALID_JULIAN(tm.tm_year, tm.tm_mon, tm.tm_mday))
        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))
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("date out of range: \"%s\"", text_to_cstring(date_txt))));
 
    PG_RETURN_DATEADT(result);
}

References collid, date2j(), do_to_timestamp(), ereport, errcode(), errmsg(), ERROR, IS_VALID_DATE, IS_VALID_JULIAN, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_DATEADT, POSTGRES_EPOCH_JDATE, text_to_cstring(), tm, pg_tm::tm_mday, pg_tm::tm_mon, and pg_tm::tm_year.

to_timestamp()

Datum to_timestamp

(

PG_FUNCTION_ARGS

)

Definition at line 4072 of file formatting.c.

{
    text       *date_txt = PG_GETARG_TEXT_PP(0);
    text       *fmt = PG_GETARG_TEXT_PP(1);
    Oid         collid = PG_GET_COLLATION();
    Timestamp   result;
    int         tz;
    struct pg_tm tm;
    struct fmt_tz ftz;
    fsec_t      fsec;
    int         fprec;
 
    do_to_timestamp(date_txt, fmt, collid, false,
                    &tm, &fsec, &ftz, &fprec, NULL, NULL);
 
    /* Use the specified time zone, if any. */
    if (ftz.has_tz)
        tz = ftz.gmtoffset;
    else
        tz = DetermineTimeZoneOffset(&tm, session_timezone);
 
    if (tm2timestamp(&tm, fsec, &tz, &result) != 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                 errmsg("timestamp out of range")));
 
    /* Use the specified fractional precision, if any. */
    if (fprec)
        AdjustTimestampForTypmod(&result, fprec, NULL);
 
    PG_RETURN_TIMESTAMP(result);
}

References AdjustTimestampForTypmod(), collid, DetermineTimeZoneOffset(), do_to_timestamp(), ereport, errcode(), errmsg(), ERROR, fmt_tz::gmtoffset, fmt_tz::has_tz, PG_GET_COLLATION, PG_GETARG_TEXT_PP, PG_RETURN_TIMESTAMP, session_timezone, tm, and tm2timestamp().

Variable Documentation

adbc_strings

const char* const adbc_strings[] = {ad_STR, bc_STR, AD_STR, BC_STR, NULL}

static

Definition at line 207 of file formatting.c.

Referenced by DCH_from_char().

adbc_strings_long

const char* const adbc_strings_long[] = {a_d_STR, b_c_STR, A_D_STR, B_C_STR, NULL}

static

Definition at line 208 of file formatting.c.

Referenced by DCH_from_char().

ampm_strings

const char* const ampm_strings[] = {am_STR, pm_STR, AM_STR, PM_STR, NULL}

static

Definition at line 233 of file formatting.c.

Referenced by DCH_from_char().

ampm_strings_long

const char* const ampm_strings_long[] = {a_m_STR, p_m_STR, A_M_STR, P_M_STR, NULL}

static

Definition at line 234 of file formatting.c.

Referenced by DCH_from_char().

days_short

const char* const days_short[]

static

Initial value:

= {
    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
}

Definition at line 174 of file formatting.c.

Referenced by DCH_from_char(), and DCH_to_char().

DCH_index

const int DCH_index[KeyWord_INDEX_SIZE]

static

Initial value:

= {
 
    
 
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, DCH_A_D, DCH_B_C, DCH_CC, DCH_DAY, -1,
    DCH_FF1, -1, DCH_HH24, DCH_IDDD, DCH_J, -1, -1, DCH_MI, -1, DCH_OF,
    DCH_P_M, DCH_Q, DCH_RM, DCH_SSSSS, DCH_TZH, DCH_US, -1, DCH_WW, -1, DCH_Y_YYY,
    -1, -1, -1, -1, -1, -1, -1, DCH_a_d, DCH_b_c, DCH_cc,
    DCH_day, -1, DCH_ff1, -1, DCH_hh24, DCH_iddd, DCH_j, -1, -1, DCH_mi,
    -1, DCH_of, DCH_p_m, DCH_q, DCH_rm, DCH_sssss, DCH_tzh, DCH_us, -1, DCH_ww,
    -1, DCH_y_yyy, -1, -1, -1, -1
 
    
}

Definition at line 976 of file formatting.c.

Referenced by datetime_format_has_tz(), datetime_to_char_body(), DCH_cache_fetch(), and do_to_timestamp().

DCH_keywords

const KeyWord DCH_keywords[]

static

Definition at line 805 of file formatting.c.

Referenced by datetime_format_has_tz(), datetime_to_char_body(), DCH_cache_fetch(), and do_to_timestamp().

DCH_suff

const KeySuffix DCH_suff[]

static

Initial value:

= {
    {"FM", 2, DCH_SUFFIX_FM, SUFFTYPE_PREFIX},
    {"fm", 2, DCH_SUFFIX_FM, SUFFTYPE_PREFIX},
    {"TM", TM_SUFFIX_LEN, DCH_SUFFIX_TM, SUFFTYPE_PREFIX},
    {"tm", 2, DCH_SUFFIX_TM, SUFFTYPE_PREFIX},
    {"TH", 2, DCH_SUFFIX_TH, SUFFTYPE_POSTFIX},
    {"th", 2, DCH_SUFFIX_th, SUFFTYPE_POSTFIX},
    {"SP", 2, DCH_SUFFIX_SP, SUFFTYPE_POSTFIX},
    
    {NULL, 0, 0, 0}
}

Definition at line 601 of file formatting.c.

Referenced by datetime_format_has_tz(), datetime_to_char_body(), DCH_cache_fetch(), and do_to_timestamp().

DCHCache

DCHCacheEntry* DCHCache[DCH_CACHE_ENTRIES]

static

Definition at line 401 of file formatting.c.

Referenced by DCH_cache_getnew(), DCH_cache_search(), and DCH_prevent_counter_overflow().

DCHCounter

int DCHCounter = 0

static

Definition at line 403 of file formatting.c.

Referenced by DCH_cache_getnew(), DCH_cache_search(), and DCH_prevent_counter_overflow().

months_full

const char* const months_full[]

static

Initial value:

= {
    "January", "February", "March", "April", "May", "June", "July",
    "August", "September", "October", "November", "December", NULL
}

Definition at line 169 of file formatting.c.

Referenced by DCH_from_char(), and DCH_to_char().

n_DCHCache

int n_DCHCache = 0

static

Definition at line 402 of file formatting.c.

Referenced by DCH_cache_getnew(), DCH_cache_search(), and DCH_prevent_counter_overflow().

n_NUMCache

int n_NUMCache = 0

static

Definition at line 407 of file formatting.c.

Referenced by NUM_cache_getnew(), NUM_cache_search(), and NUM_prevent_counter_overflow().

NUM_index

const int NUM_index[KeyWord_INDEX_SIZE]

static

Initial value:

= {
 
    
 
    -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, NUM_COMMA, -1, NUM_DEC, -1, NUM_0, -1,
    -1, -1, -1, -1, -1, -1, -1, NUM_9, -1, -1,
    -1, -1, -1, -1, -1, -1, NUM_B, NUM_C, NUM_D, NUM_E,
    NUM_FM, NUM_G, -1, -1, -1, -1, NUM_L, NUM_MI, -1, -1,
    NUM_PL, -1, NUM_RN, NUM_SG, NUM_TH, -1, NUM_V, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, NUM_b, NUM_c,
    NUM_d, NUM_e, NUM_fm, NUM_g, -1, -1, -1, -1, NUM_l, NUM_mi,
    -1, -1, NUM_pl, -1, NUM_rn, NUM_sg, NUM_th, -1, NUM_v, -1,
    -1, -1, -1, -1, -1, -1
 
    
}

Definition at line 999 of file formatting.c.

Referenced by NUM_cache(), and NUM_cache_fetch().

NUM_keywords

const KeyWord NUM_keywords[]

static

Definition at line 929 of file formatting.c.

Referenced by NUM_cache(), and NUM_cache_fetch().

NUMCache

NUMCacheEntry* NUMCache[NUM_CACHE_ENTRIES]

static

Definition at line 406 of file formatting.c.

Referenced by NUM_cache_getnew(), NUM_cache_search(), and NUM_prevent_counter_overflow().

NUMCounter

int NUMCounter = 0

static

Definition at line 408 of file formatting.c.

Referenced by NUM_cache_getnew(), NUM_cache_search(), and NUM_prevent_counter_overflow().

numTH

const char* const numTH[] = {"ST", "ND", "RD", "TH", NULL}

static

Definition at line 283 of file formatting.c.

Referenced by get_th().

numth

const char* const numth[] = {"st", "nd", "rd", "th", NULL}

static

Definition at line 284 of file formatting.c.

Referenced by get_th().

rm1

const char* const rm1[] = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", NULL}

static

Definition at line 250 of file formatting.c.

Referenced by int_to_roman().

rm10

const char* const rm10[] = {"X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", NULL}

static

Definition at line 251 of file formatting.c.

Referenced by int_to_roman().

rm100

const char* const rm100[] = {"C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", NULL}

static

Definition at line 252 of file formatting.c.

Referenced by int_to_roman().

rm_months_lower

const char* const rm_months_lower[]

static

Initial value:

=
{"xii", "xi", "x", "ix", "viii", "vii", "vi", "v", "iv", "iii", "ii", "i", NULL}

Definition at line 244 of file formatting.c.

Referenced by DCH_from_char(), and DCH_to_char().

rm_months_upper

const char* const rm_months_upper[]

static

Initial value:

=
{"XII", "XI", "X", "IX", "VIII", "VII", "VI", "V", "IV", "III", "II", "I", NULL}

Definition at line 241 of file formatting.c.

Referenced by DCH_to_char().