Skip to content

P
Postgres FD Implementation
Commit 4a3a1e2c authored by Bruce Momjian's avatar Bruce Momjian
Browse files
Options

Hi, 

 small changes in formatting.c code (better memory usage ...etc.) and
better
to_char's cache (will fastly for more to_char()s in one query).

(It is probably end of to_char() development in 7.0 cycle.)

                                                Karel
parent 6358e654
Hide whitespace changes
Inline Side-by-side
Showing with 379 additions and 198 deletions
src/backend/utils/adt/formatting.c
View file @ 4a3a1e2c
/* -----------------------------------------------------------------------
* formatting.c
*
* $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.5 2000/03/08 01:34:36 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.6 2000/03/16 01:35:41 momjian Exp $
*
*
* Portions Copyright (c) 1999-2000, PostgreSQL, Inc
......@@ -14,11 +14,9 @@
*
*
* Cache & Memory:
* Routines use (itself) internal cache for format pictures. If
* new format arg is same as a last format string, routines do not
* call the format-parser.
* Routines use (itself) internal cache for format pictures.
*
* The cache uses a static buffer and is persistent across transactions.
* The cache uses a static buffers and is persistent across transactions.
* If format-picture is bigger than cache buffer, parser is called always.
*
* NOTE for Number version:
......@@ -90,18 +88,11 @@
* Maximal length of one node
* ----------
*/
#define DCH_MAX_ITEM_SIZ 9 /* some month name ? */
#define NUM_MAX_ITEM_SIZ 16 /* roman number */
#define DCH_MAX_ITEM_SIZ 9 /* max julian day */
#define NUM_MAX_ITEM_SIZ 8 /* roman number (RN has 15 chars) */
/* ----------
* Format picture cache limits
* ----------
*/
#define NUM_CACHE_SIZE 64
#define DCH_CACHE_SIZE 128
/* ----------
* More in float.c
* More is in float.c
* ----------
*/
#define MAXFLOATWIDTH 64
......@@ -282,6 +273,42 @@ typedef struct {
#define IS_ROMAN(_f) ((_f)->flag & NUM_F_ROMAN)
#define IS_MULTI(_f) ((_f)->flag & NUM_F_MULTI)
/* ----------
* Format picture cache
* (cache size:
* Number part = NUM_CACHE_SIZE * NUM_CACHE_FIELDS
* Date-time part = DCH_CACHE_SIZE * DCH_CACHE_FIELDS
* )
* ----------
*/
#define NUM_CACHE_SIZE 64
#define NUM_CACHE_FIELDS 16
#define DCH_CACHE_SIZE 128
#define DCH_CACHE_FIELDS 16
typedef struct {
FormatNode format [ DCH_CACHE_SIZE +1];
char str [ DCH_CACHE_SIZE +1];
int age;
} DCHCacheEntry;
typedef struct {
FormatNode format [ NUM_CACHE_SIZE +1];
char str [ NUM_CACHE_SIZE +1];
int age;
NUMDesc Num;
} NUMCacheEntry;
static DCHCacheEntry DCHCache [ DCH_CACHE_FIELDS +1]; /* global cache for date/time part */
static int n_DCHCache = 0; /* number of entries */
static int DCHCounter = 0;
static NUMCacheEntry NUMCache [ NUM_CACHE_FIELDS +1]; /* global cache for number part */
static int n_NUMCache = 0; /* number of entries */
static int NUMCounter = 0;
#define MAX_INT32 (2147483640)
/* ----------
* Private global-modul definitions
* ----------
......@@ -625,8 +652,7 @@ static int dch_global(int arg, char *inout, int suf, int flag, FormatNode *node)
static int dch_time(int arg, char *inout, int suf, int flag, FormatNode *node);
static int dch_date(int arg, char *inout, int suf, int flag, FormatNode *node);
static char *fill_str(char *str, int c, int max);
static FormatNode *NUM_cache( int len, char *CacheStr, FormatNode *CacheFormat,
NUMDesc *CacheNum, NUMDesc *Num, char *pars_str, int *flag);
static FormatNode *NUM_cache( int len, NUMDesc *Num, char *pars_str, int *flag);
static char *int_to_roman(int number);
static void NUM_prepare_locale(NUMProc *Np);
static char *get_last_relevant_decnum(char *num);
......@@ -634,6 +660,10 @@ static void NUM_numpart_from_char(NUMProc *Np, int id, int plen);
static void NUM_numpart_to_char(NUMProc *Np, int id);
static char *NUM_processor (FormatNode *node, NUMDesc *Num, char *inout, char *number,
int plen, int sign, int type);
static DCHCacheEntry *DCH_cache_search( char *str );
static DCHCacheEntry *DCH_cache_getnew( char *str );
static NUMCacheEntry *NUM_cache_search( char *str );
static NUMCacheEntry *NUM_cache_getnew( char *str );
/* ----------
......@@ -1259,7 +1289,7 @@ dump_index(KeyWord *k, int *index)
/* ----------
* Global format opton for DCH version
* Global format option for DCH version
* ----------
*/
static int
......@@ -1384,7 +1414,7 @@ dch_time(int arg, char *inout, int suf, int flag, FormatNode *node)
#define CHECK_SEQ_SEARCH(_l, _s) { \
if (_l <= 0) { \
elog(ERROR, "to_datatime(): bad value for %s", _s); \
elog(ERROR, "to_timestamp(): bad value for %s", _s); \
} \
}
......@@ -1778,6 +1808,84 @@ dch_date(int arg, char *inout, int suf, int flag, FormatNode *node)
return -1;
}
static DCHCacheEntry *
DCH_cache_getnew( char *str )
{
DCHCacheEntry *ent = NULL;
/* counter overload check - paranoa? */
if (DCHCounter + DCH_CACHE_FIELDS >= MAX_INT32) {
DCHCounter = 0;
for(ent = DCHCache; ent <= (DCHCache + DCH_CACHE_FIELDS); ent++)
ent->age = (++DCHCounter);
}
/* ----------
* Cache is full - needs remove any older entry
* ----------
*/
if (n_DCHCache > DCH_CACHE_FIELDS) {
DCHCacheEntry *old = DCHCache+0;
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "Cache is full (%d)", n_DCHCache);
#endif
for(ent = DCHCache; ent <= (DCHCache + DCH_CACHE_FIELDS); ent++) {
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
strcpy(old->str, str); /* check str size before this func. */
/* old->format fill parser */
old->age = (++DCHCounter);
return old;
} else {
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "NEW (%d)", n_DCHCache);
#endif
ent = DCHCache + n_DCHCache;
strcpy(ent->str, str); /* check str size before this func. */
/* ent->format fill parser */
ent->age = (++DCHCounter);
++n_DCHCache;
return ent;
}
return (DCHCacheEntry *) NULL; /* never */
}
static DCHCacheEntry *
DCH_cache_search( char *str )
{
int i = 0;
DCHCacheEntry *ent;
/* counter overload check - paranoa? */
if (DCHCounter + DCH_CACHE_FIELDS >= MAX_INT32) {
DCHCounter = 0;
for(ent = DCHCache; ent <= (DCHCache + DCH_CACHE_FIELDS); ent++)
ent->age = (++DCHCounter);
}
for(ent = DCHCache; ent <= (DCHCache + DCH_CACHE_FIELDS); ent++) {
if (i == n_DCHCache)
break;
if (strcmp(ent->str, str) == 0) {
ent->age = (++DCHCounter);
return ent;
}
i++;
}
return (DCHCacheEntry *) NULL;
}
/****************************************************************************
* Public routines
***************************************************************************/
......@@ -1789,23 +1897,19 @@ dch_date(int arg, char *inout, int suf, int flag, FormatNode *node)
text *
timestamp_to_char(Timestamp *dt, text *fmt)
{
static FormatNode CacheFormat[ DCH_CACHE_SIZE +1];
static char CacheStr[ DCH_CACHE_SIZE +1];
text *result;
text *result, *result_tmp;
FormatNode *format;
int flag=0;
char *str;
double fsec;
char *tzn;
int len=0, tz, x=0;
int len=0, tz, flag = 0, x=0;
if ((!PointerIsValid(dt)) || (!PointerIsValid(fmt)))
return NULL;
len = VARSIZE(fmt) - VARHDRSZ;
if ((!len) || (TIMESTAMP_NOT_FINITE(*dt)))
if ((!len) || (TIMESTAMP_NOT_FINITE(*dt)))
return textin("");
tm->tm_sec =0; tm->tm_year =0;
......@@ -1814,19 +1918,19 @@ timestamp_to_char(Timestamp *dt, text *fmt)
tm->tm_mday =1; tm->tm_isdst =0;
tm->tm_mon =1;
if (TIMESTAMP_IS_EPOCH(*dt)) {
x = timestamp2tm(SetTimestamp(*dt), NULL, tm, &fsec, NULL);
} else if (TIMESTAMP_IS_CURRENT(*dt)) {
x = timestamp2tm(SetTimestamp(*dt), &tz, tm, &fsec, &tzn);
} else {
x = timestamp2tm(*dt, &tz, tm, &fsec, &tzn);
}
if (x!=0)
elog(ERROR, "to_char(): Unable to convert timestamp to tm");
if (TIMESTAMP_IS_EPOCH(*dt)) {
x = timestamp2tm(SetTimestamp(*dt), NULL, tm, &fsec, NULL);
} else if (TIMESTAMP_IS_CURRENT(*dt)) {
x = timestamp2tm(SetTimestamp(*dt), &tz, tm, &fsec, &tzn);
} else {
x = timestamp2tm(*dt, &tz, tm, &fsec, &tzn);
}
if (x!=0)
elog(ERROR, "to_char(): Unable to convert timestamp to tm");
tm->tm_wday = (date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1) % 7;
tm->tm_yday = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - date2j(tm->tm_year, 1,1) +1;
......@@ -1850,7 +1954,7 @@ timestamp_to_char(Timestamp *dt, text *fmt)
* ----------
*/
if ( len > DCH_CACHE_SIZE ) {
format = (FormatNode *) palloc((len + 1) * sizeof(FormatNode));
flag = 1;
......@@ -1865,33 +1969,29 @@ timestamp_to_char(Timestamp *dt, text *fmt)
* Use cache buffers
* ----------
*/
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "DCH_TO_CHAR() Len: %d", len);
elog(DEBUG_elog_output, "DCH_TO_CHAR() Cache - str: >%s<", CacheStr);
elog(DEBUG_elog_output, "DCH_TO_CHAR() Arg.str: >%s<", str);
#endif
DCHCacheEntry *ent;
flag = 0;
if (strcmp(CacheStr, str) != 0) {
if ((ent = DCH_cache_search(str)) == NULL) {
ent = DCH_cache_getnew(str);
/* ----------
* Can't use the cache, must run parser and save a original
* format-picture string to the cache.
* Not in the cache, must run parser and save a new
* format-picture to the cache.
* ----------
*/
strncpy(CacheStr, str, DCH_CACHE_SIZE);
parse_format(CacheFormat, str, DCH_keywords,
parse_format(ent->format, str, DCH_keywords,
DCH_suff, DCH_index, DCH_TYPE, NULL);
(ent->format + len)->type = NODE_TYPE_END; /* Paranoa? */
#ifdef DEBUG_TO_FROM_CHAR
/* dump_node(CacheFormat, len); */
/* dump_node(ent->format, len); */
/* dump_index(DCH_keywords, DCH_index); */
#endif
(CacheFormat + len)->type = NODE_TYPE_END; /* Paranoa? */
}
format = CacheFormat;
}
format = ent->format;
}
DCH_processor(format, VARDATA(result), TO_CHAR);
......@@ -1900,7 +2000,20 @@ timestamp_to_char(Timestamp *dt, text *fmt)
pfree(format);
pfree(str);
VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
/* ----------
* for result is allocated max memory, which current format-picture
* needs, now it must be re-allocate to result real size
* ----------
*/
len = strlen(VARDATA(result));
result_tmp = result;
result = (text *) palloc( len + 1 + VARHDRSZ);
strcpy( VARDATA(result), VARDATA(result_tmp));
VARSIZE(result) = len + VARHDRSZ;
pfree(result_tmp);
return result;
}
......@@ -1915,9 +2028,6 @@ timestamp_to_char(Timestamp *dt, text *fmt)
Timestamp *
to_timestamp(text *date_str, text *fmt)
{
static FormatNode CacheFormat[ DCH_CACHE_SIZE +1];
static char CacheStr[ DCH_CACHE_SIZE +1];
FormatNode *format;
int flag=0;
Timestamp *result;
......@@ -1963,37 +2073,35 @@ to_timestamp(text *date_str, text *fmt)
DCH_suff, DCH_index, DCH_TYPE, NULL);
(format + len)->type = NODE_TYPE_END; /* Paranoa? */
} else {
/* ----------
* Use cache buffers
* ----------
*/
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "DCH_TO_CHAR() Len: %d", len);
elog(DEBUG_elog_output, "DCH_TO_CHAR() Cache - str: >%s<", CacheStr);
elog(DEBUG_elog_output, "DCH_TO_CHAR() Arg.str: >%s<", str);
#endif
DCHCacheEntry *ent;
flag = 0;
if (strcmp(CacheStr, str) != 0) {
if ((ent = DCH_cache_search(str)) == NULL) {
ent = DCH_cache_getnew(str);
/* ----------
* Can't use the cache, must run parser and save a original
* format-picture string to the cache.
* Not in the cache, must run parser and save a new
* format-picture to the cache.
* ----------
*/
strncpy(CacheStr, str, DCH_CACHE_SIZE);
parse_format(CacheFormat, str, DCH_keywords,
DCH_suff, DCH_index, DCH_TYPE, NULL);
(CacheFormat + len)->type = NODE_TYPE_END; /* Paranoa? */
}
format = CacheFormat;
}
*/
parse_format(ent->format, str, DCH_keywords,
DCH_suff, DCH_index, DCH_TYPE, NULL);
(ent->format + len)->type = NODE_TYPE_END; /* Paranoa? */
#ifdef DEBUG_TO_FROM_CHAR
/* dump_node(ent->format, len); */
/* dump_index(DCH_keywords, DCH_index); */
#endif
}
format = ent->format;
}
/* ----------
* Call action for each node in FormatNode tree
......@@ -2083,16 +2191,107 @@ fill_str(char *str, int c, int max)
return str;
}
#define zeroize_NUM(_n) { \
(_n)->flag = 0; \
(_n)->lsign = 0; \
(_n)->pre = 0; \
(_n)->post = 0; \
(_n)->pre_lsign_num = 0; \
(_n)->need_locale = 0; \
(_n)->multi = 0; \
(_n)->zero_start = 0; \
(_n)->zero_end = 0; \
}
static NUMCacheEntry *
NUM_cache_getnew( char *str )
{
NUMCacheEntry *ent = NULL;
/* counter overload check - paranoa? */
if (NUMCounter + NUM_CACHE_FIELDS >= MAX_INT32) {
NUMCounter = 0;
for(ent = NUMCache; ent <= (NUMCache + NUM_CACHE_FIELDS); ent++)
ent->age = (++NUMCounter);
}
/* ----------
* Cache is full - needs remove any older entry
* ----------
*/
if (n_NUMCache > NUM_CACHE_FIELDS) {
NUMCacheEntry *old = NUMCache+0;
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "Cache is full (%d)", n_NUMCache);
#endif
for(ent = NUMCache; ent <= (NUMCache + NUM_CACHE_FIELDS); ent++) {
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
strcpy(old->str, str); /* check str size before this func. */
/* old->format fill parser */
old->age = (++NUMCounter);
ent = old;
} else {
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "NEW (%d)", n_NUMCache);
#endif
ent = NUMCache + n_NUMCache;
strcpy(ent->str, str); /* check str size before this func. */
/* ent->format fill parser */
ent->age = (++NUMCounter);
++n_NUMCache;
}
zeroize_NUM(&ent->Num);
return ent; /* never */
}
static NUMCacheEntry *
NUM_cache_search( char *str )
{
int i = 0;
NUMCacheEntry *ent;
/* counter overload check - paranoa? */
if (NUMCounter + NUM_CACHE_FIELDS >= MAX_INT32) {
NUMCounter = 0;
for(ent = NUMCache; ent <= (NUMCache + NUM_CACHE_FIELDS); ent++)
ent->age = (++NUMCounter);
}
for(ent = NUMCache; ent <= (NUMCache + NUM_CACHE_FIELDS); ent++) {
if (i == n_NUMCache)
break;
if (strcmp(ent->str, str) == 0) {
ent->age = (++NUMCounter);
return ent;
}
i++;
}
return (NUMCacheEntry *) NULL;
}
/* ----------
* Cache routine for NUM to_char version
* ----------
*/
static FormatNode *
NUM_cache( int len, char *CacheStr, FormatNode *CacheFormat,
NUMDesc *CacheNum, NUMDesc *Num, char *pars_str, int *flag)
NUM_cache( int len, NUMDesc *Num, char *pars_str, int *flag)
{
FormatNode *format;
FormatNode *format = NULL;
char *str;
/* ----------
......@@ -2113,86 +2312,57 @@ NUM_cache( int len, char *CacheStr, FormatNode *CacheFormat,
format = (FormatNode *) palloc((len + 1) * sizeof(FormatNode));
*flag = 1;
Num->flag = 0;
Num->lsign = 0;
Num->pre = 0;
Num->post = 0;
Num->pre_lsign_num = 0;
Num->zero_start = 0;
Num->zero_end = 0;
Num->need_locale = 0;
Num->multi = 0;
zeroize_NUM(Num);
parse_format(format, str, NUM_keywords,
NULL, NUM_index, NUM_TYPE, Num);
(format + len)->type = NODE_TYPE_END; /* Paranoa? */
pfree(str);
return format;
} else {
/* ----------
* Use cache buffer
* Use cache buffers
* ----------
*/
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "NUM_TO_CHAR() Len: %d", len);
elog(DEBUG_elog_output, "NUM_TO_CHAR() Cache - str: >%s<", CacheStr);
elog(DEBUG_elog_output, "NUM_TO_CHAR() Arg.str: >%s<", str);
#endif
*flag = 0;
NUMCacheEntry *ent;
flag = 0;
if (strcmp(CacheStr, str) != 0) {
if ((ent = NUM_cache_search(str)) == NULL) {
ent = NUM_cache_getnew(str);
/* ----------
* Can't use the cache, must run parser and save a original
* format-picture string to the cache.
* Not in the cache, must run parser and save a new
* format-picture to the cache.
* ----------
*/
strncpy(CacheStr, str, NUM_CACHE_SIZE);
/* ----------
* Set zeros to CacheNum struct
* ----------
*/
CacheNum->flag = 0;
CacheNum->lsign = 0;
CacheNum->pre = 0;
CacheNum->post = 0;
CacheNum->pre_lsign_num = 0;
CacheNum->need_locale = 0;
CacheNum->multi = 0;
CacheNum->zero_start = 0;
CacheNum->zero_end = 0;
parse_format(CacheFormat, str, NUM_keywords,
NULL, NUM_index, NUM_TYPE, CacheNum);
#ifdef DEBUG_TO_FROM_CHAR
/* dump_node(CacheFormat, len); */
/* dump_index(NUM_keywords, NUM_index); */
#endif
(CacheFormat + len)->type = NODE_TYPE_END; /* Paranoa? */
}
/* ----------
parse_format(ent->format, str, NUM_keywords,
NULL, NUM_index, NUM_TYPE, &ent->Num);
(ent->format + len)->type = NODE_TYPE_END; /* Paranoa? */
}
format = ent->format;
/* ----------
* Copy cache to used struct
* ----------
*/
Num->flag = CacheNum->flag;
Num->lsign = CacheNum->lsign;
Num->pre = CacheNum->pre;
Num->post = CacheNum->post;
Num->pre_lsign_num = CacheNum->pre_lsign_num;
Num->need_locale = CacheNum->need_locale;
Num->multi = CacheNum->multi;
Num->zero_start = CacheNum->zero_start;
Num->zero_end = CacheNum->zero_end;
pfree(str);
return CacheFormat;
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;
}
pfree(str);
return format;
}
......@@ -2332,8 +2502,10 @@ get_last_relevant_decnum(char *num)
{
char *result,
*p = strchr(num, '.');
/*elog(NOTICE, "CALL: get_last_relevant_decnum()");*/
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "CALL: get_last_relevant_decnum()");
#endif
if (!p)
p = num;
......@@ -2359,14 +2531,17 @@ NUM_numpart_from_char(NUMProc *Np, int id, int plen)
elog(DEBUG_elog_output, " --- scan start --- ");
#endif
#define OVERLOAD_TEST (Np->inout_p >= Np->inout + plen)
if (*Np->inout_p == ' ')
Np->inout_p++;
#define OVERLOAD_TEST (Np->inout_p >= Np->inout + plen)
if (*Np->inout_p == ' ')
Np->inout_p++;
if (OVERLOAD_TEST)
return;
/* ----------
* read sign
* ----------
......@@ -2420,7 +2595,7 @@ NUM_numpart_from_char(NUMProc *Np, int id, int plen)
Np->inout_p++;
}
}
if (OVERLOAD_TEST)
return;
......@@ -2441,7 +2616,7 @@ NUM_numpart_from_char(NUMProc *Np, int id, int plen)
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "Read digit (%c).", *Np->inout_p);
#endif
#endif
/* ----------
* read decimal point
......@@ -3047,15 +3222,14 @@ NUM_processor (FormatNode *node, NUMDesc *Num, char *inout, char *number,
return textin(""); \
\
result = (text *) palloc( (len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ); \
format = NUM_cache(len, CacheStr, CacheFormat, &CacheNum, &Num, \
VARDATA(fmt), &flag); \
format = NUM_cache(len, &Num, VARDATA(fmt), &flag); \
}
/* ----------
* MACRO: Finish part of NUM
* ----------
*/
#define NUM_TOCHAR_finish { \
#define NUM_TOCHAR_finish { \
\
NUM_processor(format, &Num, VARDATA(result), \
numstr, plen, sign, TO_CHAR); \
......@@ -3064,21 +3238,29 @@ NUM_processor (FormatNode *node, NUMDesc *Num, char *inout, char *number,
if (flag) \
pfree(format); \
\
VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; \
/* ---------- \
* for result is allocated max memory, which current format-picture\
* needs, now it must be re-allocate to result real size \
* ---------- \
*/ \
len = strlen(VARDATA(result)); \
result_tmp = result; \
result = (text *) palloc( len + 1 + VARHDRSZ); \
\
strcpy( VARDATA(result), VARDATA(result_tmp)); \
VARSIZE(result) = len + VARHDRSZ; \
pfree(result_tmp); \
}
/* -------------------
* NUMERIC to_number()
* NUMERIC to_number() (convert string to numeric)
* -------------------
*/
Numeric
numeric_to_number(text *value, text *fmt)
{
static FormatNode CacheFormat[ NUM_CACHE_SIZE +1];
static char CacheStr[ NUM_CACHE_SIZE +1];
static NUMDesc CacheNum;
NUMDesc Num;
Numeric result;
FormatNode *format;
char *numstr;
int flag=0;
......@@ -3094,8 +3276,7 @@ numeric_to_number(text *value, text *fmt)
if (!len)
return numeric_in(NULL, 0, 0);
format = NUM_cache(len, CacheStr, CacheFormat, &CacheNum, &Num,
VARDATA(fmt), &flag);
format = NUM_cache(len, &Num, VARDATA(fmt), &flag);
numstr = (char *) palloc( (len * NUM_MAX_ITEM_SIZ) + 1);
......@@ -3104,8 +3285,13 @@ numeric_to_number(text *value, text *fmt)
scale = Num.post;
precision = MAX(0, Num.pre) + scale;
if (flag)
pfree(format);
return numeric_in(numstr, 0, ((precision << 16) | scale) + VARHDRSZ);
result = numeric_in(numstr, 0, ((precision << 16) | scale) + VARHDRSZ);
pfree(numstr);
return result;
}
/* ------------------
......@@ -3115,16 +3301,13 @@ numeric_to_number(text *value, text *fmt)
text *
numeric_to_char(Numeric value, text *fmt)
{
static FormatNode CacheFormat[ NUM_CACHE_SIZE +1];
static char CacheStr[ NUM_CACHE_SIZE +1];
static NUMDesc CacheNum;
NUMDesc Num;
FormatNode *format;
text *result;
text *result, *result_tmp;
int flag=0;
int len=0, plen=0, sign=0;
char *numstr, *orgnum, *p;
Numeric x = NULL;
NUM_TOCHAR_prepare;
......@@ -3133,18 +3316,29 @@ numeric_to_char(Numeric value, text *fmt)
* ----------
*/
if (IS_ROMAN(&Num)) {
numstr = orgnum = int_to_roman( numeric_int4( numeric_round(value, 0)));
x = numeric_round(value, 0);
numstr = orgnum = int_to_roman( numeric_int4( x ));
pfree(x);
} else {
Numeric val = value;
Numeric val = value;
if (IS_MULTI(&Num)) {
val = numeric_mul(value,
numeric_power(int4_numeric(10), int4_numeric(Num.multi)));
Numeric a = int4_numeric(10);
Numeric b = int4_numeric(Num.multi);
x = numeric_power(a, b);
val = numeric_mul(value, x);
pfree(x);
pfree(a);
pfree(b);
Num.pre += Num.multi;
}
orgnum = numeric_out( numeric_round(val, Num.post) );
x = numeric_round(val, Num.post);
orgnum = numeric_out( x );
pfree(x);
if (*orgnum == '-') { /* < 0 */
sign = '-';
numstr = orgnum+1;
......@@ -3164,7 +3358,10 @@ numeric_to_char(Numeric value, text *fmt)
fill_str(numstr, '#', Num.pre);
*(numstr + Num.pre) = '.';
fill_str(numstr + 1 + Num.pre, '#', Num.post);
}
}
if (IS_MULTI(&Num))
pfree(val);
}
NUM_TOCHAR_finish;
......@@ -3178,13 +3375,9 @@ numeric_to_char(Numeric value, text *fmt)
text *
int4_to_char(int32 value, text *fmt)
{
static FormatNode CacheFormat[ NUM_CACHE_SIZE +1];
static char CacheStr[ NUM_CACHE_SIZE +1];
static NUMDesc CacheNum;
NUMDesc Num;
FormatNode *format;
text *result;
text *result, *result_tmp;
int flag=0;
int len=0, plen=0, sign=0;
char *numstr, *orgnum;
......@@ -3247,13 +3440,9 @@ int4_to_char(int32 value, text *fmt)
text *
int8_to_char(int64 *value, text *fmt)
{
static FormatNode CacheFormat[ NUM_CACHE_SIZE +1];
static char CacheStr[ NUM_CACHE_SIZE +1];
static NUMDesc CacheNum;
NUMDesc Num;
FormatNode *format;
text *result;
text *result, *result_tmp;
int flag=0;
int len=0, plen=0, sign=0;
char *numstr, *orgnum;
......@@ -3317,13 +3506,9 @@ int8_to_char(int64 *value, text *fmt)
text *
float4_to_char(float32 value, text *fmt)
{
static FormatNode CacheFormat[ NUM_CACHE_SIZE +1];
static char CacheStr[ NUM_CACHE_SIZE +1];
static NUMDesc CacheNum;
NUMDesc Num;
FormatNode *format;
text *result;
text *result, *result_tmp;
int flag=0;
int len=0, plen=0, sign=0;
char *numstr, *orgnum, *p;
......@@ -3385,13 +3570,9 @@ float4_to_char(float32 value, text *fmt)
text *
float8_to_char(float64 value, text *fmt)
{
static FormatNode CacheFormat[ NUM_CACHE_SIZE +1];
static char CacheStr[ NUM_CACHE_SIZE +1];
static NUMDesc CacheNum;
NUMDesc Num;
FormatNode *format;
text *result;
text *result, *result_tmp;
int flag=0;
int len=0, plen=0, sign=0;
char *numstr, *orgnum, *p;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment