From 1fd687a035558238c0e3cab09fc22dc61a088869 Mon Sep 17 00:00:00 2001 From: Andrew Gierth Date: Sat, 1 Feb 2020 21:57:14 +0000 Subject: [PATCH] Optimizations for integer to decimal output. Using a lookup table of digit pairs reduces the number of divisions needed, and calculating the length upfront saves some work; these ideas are taken from the code previously committed for floats. David Fetter, reviewed by Kyotaro Horiguchi, Tels, and me. Discussion: https://postgr.es/m/20190924052620.GP31596%40fetter.org --- src/backend/access/common/printsimple.c | 2 +- src/backend/utils/adt/datetime.c | 98 +++--- src/backend/utils/adt/int8.c | 1 - src/backend/utils/adt/numutils.c | 431 ++++++++++++++---------- src/include/utils/builtins.h | 8 +- 5 files changed, 300 insertions(+), 240 deletions(-) diff --git a/src/backend/access/common/printsimple.c b/src/backend/access/common/printsimple.c index 4006ebdabd..0f0b54bdae 100644 --- a/src/backend/access/common/printsimple.c +++ b/src/backend/access/common/printsimple.c @@ -112,7 +112,7 @@ printsimple(TupleTableSlot *slot, DestReceiver *self) case INT8OID: { int64 num = DatumGetInt64(value); - char str[23]; /* sign, 21 digits and '\0' */ + char str[MAXINT8LEN + 1]; pg_lltoa(num, str); pq_sendcountedtext(&buf, str, strlen(str), false); diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c index 6159296b3d..4f109111d1 100644 --- a/src/backend/utils/adt/datetime.c +++ b/src/backend/utils/adt/datetime.c @@ -388,9 +388,9 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros) Assert(precision >= 0); if (fillzeros) - cp = pg_ltostr_zeropad(cp, Abs(sec), 2); + cp = pg_ultostr_zeropad(cp, Abs(sec), 2); else - cp = pg_ltostr(cp, Abs(sec)); + cp = pg_ultostr(cp, Abs(sec)); /* fsec_t is just an int32 */ if (fsec != 0) @@ -430,7 +430,7 @@ AppendSeconds(char *cp, int sec, fsec_t fsec, int precision, bool fillzeros) * which will generate a correct answer in the minimum valid width. */ if (value) - return pg_ltostr(cp, Abs(fsec)); + return pg_ultostr(cp, Abs(fsec)); return end; } @@ -3831,20 +3831,20 @@ EncodeTimezone(char *str, int tz, int style) if (sec != 0) { - str = pg_ltostr_zeropad(str, hour, 2); + str = pg_ultostr_zeropad(str, hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, min, 2); + str = pg_ultostr_zeropad(str, min, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, sec, 2); + str = pg_ultostr_zeropad(str, sec, 2); } else if (min != 0 || style == USE_XSD_DATES) { - str = pg_ltostr_zeropad(str, hour, 2); + str = pg_ultostr_zeropad(str, hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, min, 2); + str = pg_ultostr_zeropad(str, min, 2); } else - str = pg_ltostr_zeropad(str, hour, 2); + str = pg_ultostr_zeropad(str, hour, 2); return str; } @@ -3861,40 +3861,40 @@ EncodeDateOnly(struct pg_tm *tm, int style, char *str) case USE_ISO_DATES: case USE_XSD_DATES: /* compatible with ISO date formats */ - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); *str++ = '-'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '-'; - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); break; case USE_SQL_DATES: /* compatible with Oracle/Ingres date formats */ if (DateOrder == DATEORDER_DMY) { - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = '/'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); } else { - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '/'; - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); } *str++ = '/'; - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); break; case USE_GERMAN_DATES: /* German-style date format */ - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = '.'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '.'; - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); break; @@ -3903,18 +3903,18 @@ EncodeDateOnly(struct pg_tm *tm, int style, char *str) /* traditional date-only style for Postgres */ if (DateOrder == DATEORDER_DMY) { - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = '-'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); } else { - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '-'; - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); } *str++ = '-'; - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); break; } @@ -3939,9 +3939,9 @@ EncodeDateOnly(struct pg_tm *tm, int style, char *str) void EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style, char *str) { - str = pg_ltostr_zeropad(str, tm->tm_hour, 2); + str = pg_ultostr_zeropad(str, tm->tm_hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, tm->tm_min, 2); + str = pg_ultostr_zeropad(str, tm->tm_min, 2); *str++ = ':'; str = AppendSeconds(str, tm->tm_sec, fsec, MAX_TIME_PRECISION, true); if (print_tz) @@ -3984,16 +3984,16 @@ EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char case USE_ISO_DATES: case USE_XSD_DATES: /* Compatible with ISO-8601 date formats */ - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); *str++ = '-'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '-'; - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = (style == USE_ISO_DATES) ? ' ' : 'T'; - str = pg_ltostr_zeropad(str, tm->tm_hour, 2); + str = pg_ultostr_zeropad(str, tm->tm_hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, tm->tm_min, 2); + str = pg_ultostr_zeropad(str, tm->tm_min, 2); *str++ = ':'; str = AppendTimestampSeconds(str, tm, fsec); if (print_tz) @@ -4004,23 +4004,23 @@ EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char /* Compatible with Oracle/Ingres date formats */ if (DateOrder == DATEORDER_DMY) { - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = '/'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); } else { - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '/'; - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); } *str++ = '/'; - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); *str++ = ' '; - str = pg_ltostr_zeropad(str, tm->tm_hour, 2); + str = pg_ultostr_zeropad(str, tm->tm_hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, tm->tm_min, 2); + str = pg_ultostr_zeropad(str, tm->tm_min, 2); *str++ = ':'; str = AppendTimestampSeconds(str, tm, fsec); @@ -4043,16 +4043,16 @@ EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char case USE_GERMAN_DATES: /* German variant on European style */ - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = '.'; - str = pg_ltostr_zeropad(str, tm->tm_mon, 2); + str = pg_ultostr_zeropad(str, tm->tm_mon, 2); *str++ = '.'; - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); *str++ = ' '; - str = pg_ltostr_zeropad(str, tm->tm_hour, 2); + str = pg_ultostr_zeropad(str, tm->tm_hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, tm->tm_min, 2); + str = pg_ultostr_zeropad(str, tm->tm_min, 2); *str++ = ':'; str = AppendTimestampSeconds(str, tm, fsec); @@ -4078,7 +4078,7 @@ EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *str++ = ' '; if (DateOrder == DATEORDER_DMY) { - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); *str++ = ' '; memcpy(str, months[tm->tm_mon - 1], 3); str += 3; @@ -4088,16 +4088,16 @@ EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char memcpy(str, months[tm->tm_mon - 1], 3); str += 3; *str++ = ' '; - str = pg_ltostr_zeropad(str, tm->tm_mday, 2); + str = pg_ultostr_zeropad(str, tm->tm_mday, 2); } *str++ = ' '; - str = pg_ltostr_zeropad(str, tm->tm_hour, 2); + str = pg_ultostr_zeropad(str, tm->tm_hour, 2); *str++ = ':'; - str = pg_ltostr_zeropad(str, tm->tm_min, 2); + str = pg_ultostr_zeropad(str, tm->tm_min, 2); *str++ = ':'; str = AppendTimestampSeconds(str, tm, fsec); *str++ = ' '; - str = pg_ltostr_zeropad(str, + str = pg_ultostr_zeropad(str, (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1), 4); if (print_tz) diff --git a/src/backend/utils/adt/int8.c b/src/backend/utils/adt/int8.c index 494768c190..55e0eb05da 100644 --- a/src/backend/utils/adt/int8.c +++ b/src/backend/utils/adt/int8.c @@ -26,7 +26,6 @@ #include "utils/builtins.h" #include "utils/int8.h" -#define MAXINT8LEN 25 typedef struct { diff --git a/src/backend/utils/adt/numutils.c b/src/backend/utils/adt/numutils.c index aca1102b36..a7467adb03 100644 --- a/src/backend/utils/adt/numutils.c +++ b/src/backend/utils/adt/numutils.c @@ -20,6 +20,68 @@ #include "common/int.h" #include "utils/builtins.h" +#include "port/pg_bitutils.h" + +/* + * A table of all two-digit numbers. This is used to speed up decimal digit + * generation by copying pairs of digits into the final output. + */ +static const char DIGIT_TABLE[200] = +"00" "01" "02" "03" "04" "05" "06" "07" "08" "09" +"10" "11" "12" "13" "14" "15" "16" "17" "18" "19" +"20" "21" "22" "23" "24" "25" "26" "27" "28" "29" +"30" "31" "32" "33" "34" "35" "36" "37" "38" "39" +"40" "41" "42" "43" "44" "45" "46" "47" "48" "49" +"50" "51" "52" "53" "54" "55" "56" "57" "58" "59" +"60" "61" "62" "63" "64" "65" "66" "67" "68" "69" +"70" "71" "72" "73" "74" "75" "76" "77" "78" "79" +"80" "81" "82" "83" "84" "85" "86" "87" "88" "89" +"90" "91" "92" "93" "94" "95" "96" "97" "98" "99"; + +/* + * Adapted from http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 + */ +static inline int +decimalLength32(const uint32 v) +{ + int t; + static uint32 PowersOfTen[] = + {1, 10, 100, + 1000, 10000, 100000, + 1000000, 10000000, 100000000, + 1000000000}; + /* + * Compute base-10 logarithm by dividing the base-2 logarithm by a + * good-enough approximation of the base-2 logarithm of 10 + */ + t = (pg_leftmost_one_pos32(v) + 1) * 1233 / 4096; + return t + (v >= PowersOfTen[t]); +} + +static inline int +decimalLength64(const uint64 v) +{ + int t; + static uint64 PowersOfTen[] = { + UINT64CONST(1), UINT64CONST(10), + UINT64CONST(100), UINT64CONST(1000), + UINT64CONST(10000), UINT64CONST(100000), + UINT64CONST(1000000), UINT64CONST(10000000), + UINT64CONST(100000000), UINT64CONST(1000000000), + UINT64CONST(10000000000), UINT64CONST(100000000000), + UINT64CONST(1000000000000), UINT64CONST(10000000000000), + UINT64CONST(100000000000000), UINT64CONST(1000000000000000), + UINT64CONST(10000000000000000), UINT64CONST(100000000000000000), + UINT64CONST(1000000000000000000), UINT64CONST(10000000000000000000) + }; + + /* + * Compute base-10 logarithm by dividing the base-2 logarithm by a + * good-enough approximation of the base-2 logarithm of 10 + */ + t = (pg_leftmost_one_pos64(v) + 1) * 1233 / 4096; + return t + (v >= PowersOfTen[t]); +} /* * pg_atoi: convert string to integer @@ -276,116 +338,201 @@ pg_itoa(int16 i, char *a) } /* - * pg_ltoa: converts a signed 32-bit integer to its string representation + * pg_ultoa_n: converts an unsigned 32-bit integer to its string representation, + * not NUL-terminated, and returns the length of that string representation * - * Caller must ensure that 'a' points to enough memory to hold the result - * (at least 12 bytes, counting a leading sign and trailing NUL). + * Caller must ensure that 'a' points to enough memory to hold the result (at + * least 10 bytes) + */ +int +pg_ultoa_n(uint32 value, char *a) +{ + int olength, + i = 0; + + /* Degenerate case */ + if (value == 0) + { + *a = '0'; + return 1; + } + + olength = decimalLength32(value); + + /* Compute the result string. */ + while (value >= 10000) + { + const uint32 c = value - 10000 * (value / 10000); + const uint32 c0 = (c % 100) << 1; + const uint32 c1 = (c / 100) << 1; + + char *pos = a + olength - i; + + value /= 10000; + + memcpy(pos - 2, DIGIT_TABLE + c0, 2); + memcpy(pos - 4, DIGIT_TABLE + c1, 2); + i += 4; + } + if (value >= 100) + { + const uint32 c = (value % 100) << 1; + + char *pos = a + olength - i; + + value /= 100; + + memcpy(pos - 2, DIGIT_TABLE + c, 2); + i += 2; + } + if (value >= 10) + { + const uint32 c = value << 1; + + char *pos = a + olength - i; + + memcpy(pos - 2, DIGIT_TABLE + c, 2); + } + else + { + *a = (char) ('0' + value); + } + + return olength; +} + +/* + * NUL-terminate the output of pg_ultoa_n. + * + * It is the caller's responsibility to ensure that a is at least 12 bytes long, + * which is enough room to hold a minus sign, a maximally long int32, and the + * above terminating NUL. */ void pg_ltoa(int32 value, char *a) { - char *start = a; - bool neg = false; - /* - * Avoid problems with the most negative integer not being representable - * as a positive integer. - */ - if (value == PG_INT32_MIN) + uint32 uvalue = (uint32) value; + int len; + + if (value < 0) { - memcpy(a, "-2147483648", 12); - return; - } - else if (value < 0) - { - value = -value; - neg = true; - } - - /* Compute the result string backwards. */ - do - { - int32 remainder; - int32 oldval = value; - - value /= 10; - remainder = oldval - value * 10; - *a++ = '0' + remainder; - } while (value != 0); - - if (neg) + uvalue = (uint32) 0 - uvalue; *a++ = '-'; - - /* Add trailing NUL byte, and back up 'a' to the last character. */ - *a-- = '\0'; - - /* Reverse string. */ - while (start < a) - { - char swap = *start; - - *start++ = *a; - *a-- = swap; } + len = pg_ultoa_n(uvalue, a); + a[len] = '\0'; +} + +/* + * Get the decimal representation, not NUL-terminated, and return the length of + * same. Caller must ensure that a points to at least MAXINT8LEN bytes. + */ +int +pg_ulltoa_n(uint64 value, char *a) +{ + int olength, + i = 0; + uint32 value2; + + + /* Degenerate case */ + if (value == 0) + { + *a = '0'; + return 1; + } + + olength = decimalLength64(value); + + /* Compute the result string. */ + while (value >= 100000000) + { + const uint64 q = value / 100000000; + uint32 value2 = (uint32) (value - 100000000 * q); + + const uint32 c = value2 % 10000; + const uint32 d = value2 / 10000; + const uint32 c0 = (c % 100) << 1; + const uint32 c1 = (c / 100) << 1; + const uint32 d0 = (d % 100) << 1; + const uint32 d1 = (d / 100) << 1; + + char *pos = a + olength - i; + + value = q; + + memcpy(pos - 2, DIGIT_TABLE + c0, 2); + memcpy(pos - 4, DIGIT_TABLE + c1, 2); + memcpy(pos - 6, DIGIT_TABLE + d0, 2); + memcpy(pos - 8, DIGIT_TABLE + d1, 2); + i += 8; + } + + /* Switch to 32-bit for speed */ + value2 = (uint32) value; + + if (value2 >= 10000) + { + const uint32 c = value2 - 10000 * (value2 / 10000); + const uint32 c0 = (c % 100) << 1; + const uint32 c1 = (c / 100) << 1; + + char *pos = a + olength - i; + + value2 /= 10000; + + memcpy(pos - 2, DIGIT_TABLE + c0, 2); + memcpy(pos - 4, DIGIT_TABLE + c1, 2); + i += 4; + } + if (value2 >= 100) + { + const uint32 c = (value2 % 100) << 1; + char *pos = a + olength - i; + + value2 /= 100; + + memcpy(pos - 2, DIGIT_TABLE + c, 2); + i += 2; + } + if (value2 >= 10) + { + const uint32 c = value2 << 1; + char *pos = a + olength - i; + + memcpy(pos - 2, DIGIT_TABLE + c, 2); + } + else + *a = (char) ('0' + value2); + + return olength; } /* * pg_lltoa: convert a signed 64-bit integer to its string representation * * Caller must ensure that 'a' points to enough memory to hold the result - * (at least MAXINT8LEN+1 bytes, counting a leading sign and trailing NUL). + * (at least MAXINT8LEN + 1 bytes, counting a leading sign and trailing NUL). */ void pg_lltoa(int64 value, char *a) { - char *start = a; - bool neg = false; + int len; + uint64 uvalue = value; - /* - * Avoid problems with the most negative integer not being representable - * as a positive integer. - */ - if (value == PG_INT64_MIN) + if (value < 0) { - memcpy(a, "-9223372036854775808", 21); - return; - } - else if (value < 0) - { - value = -value; - neg = true; - } - - /* Compute the result string backwards. */ - do - { - int64 remainder; - int64 oldval = value; - - value /= 10; - remainder = oldval - value * 10; - *a++ = '0' + remainder; - } while (value != 0); - - if (neg) *a++ = '-'; - - /* Add trailing NUL byte, and back up 'a' to the last character. */ - *a-- = '\0'; - - /* Reverse string. */ - while (start < a) - { - char swap = *start; - - *start++ = *a; - *a-- = swap; + uvalue = (uint64) 0 - uvalue; } + len = pg_ulltoa_n(uvalue, a); + a[len] = 0; } /* - * pg_ltostr_zeropad + * pg_ultostr_zeropad * Converts 'value' into a decimal string representation stored at 'str'. * 'minwidth' specifies the minimum width of the result; any extra space * is filled up by prefixing the number with zeros. @@ -407,62 +554,25 @@ pg_lltoa(int64 value, char *a) * result. */ char * -pg_ltostr_zeropad(char *str, int32 value, int32 minwidth) +pg_ultostr_zeropad(char *str, uint32 value, int32 minwidth) { - char *start = str; - char *end = &str[minwidth]; - int32 num = value; + int len; Assert(minwidth > 0); - /* - * Handle negative numbers in a special way. We can't just write a '-' - * prefix and reverse the sign as that would overflow for INT32_MIN. - */ - if (num < 0) + if (value < 100 && minwidth == 2) /* Short cut for common case */ { - *start++ = '-'; - minwidth--; - - /* - * Build the number starting at the last digit. Here remainder will - * be a negative number, so we must reverse the sign before adding '0' - * in order to get the correct ASCII digit. - */ - while (minwidth--) - { - int32 oldval = num; - int32 remainder; - - num /= 10; - remainder = oldval - num * 10; - start[minwidth] = '0' - remainder; - } - } - else - { - /* Build the number starting at the last digit */ - while (minwidth--) - { - int32 oldval = num; - int32 remainder; - - num /= 10; - remainder = oldval - num * 10; - start[minwidth] = '0' + remainder; - } + memcpy(str, DIGIT_TABLE + value * 2, 2); + return str + 2; } - /* - * If minwidth was not high enough to fit the number then num won't have - * been divided down to zero. We punt the problem to pg_ltostr(), which - * will generate a correct answer in the minimum valid width. - */ - if (num != 0) - return pg_ltostr(str, value); + len = pg_ultoa_n(value, str); + if (len >= minwidth) + return str + len; - /* Otherwise, return last output character + 1 */ - return end; + memmove(str + minwidth - len, str, len); + memset(str, '0', minwidth - len); + return str + minwidth; } /* @@ -484,64 +594,11 @@ pg_ltostr_zeropad(char *str, int32 value, int32 minwidth) * result. */ char * -pg_ltostr(char *str, int32 value) +pg_ultostr(char *str, uint32 value) { - char *start; - char *end; + int len = pg_ultoa_n(value, str); - /* - * Handle negative numbers in a special way. We can't just write a '-' - * prefix and reverse the sign as that would overflow for INT32_MIN. - */ - if (value < 0) - { - *str++ = '-'; - - /* Mark the position we must reverse the string from. */ - start = str; - - /* Compute the result string backwards. */ - do - { - int32 oldval = value; - int32 remainder; - - value /= 10; - remainder = oldval - value * 10; - /* As above, we expect remainder to be negative. */ - *str++ = '0' - remainder; - } while (value != 0); - } - else - { - /* Mark the position we must reverse the string from. */ - start = str; - - /* Compute the result string backwards. */ - do - { - int32 oldval = value; - int32 remainder; - - value /= 10; - remainder = oldval - value * 10; - *str++ = '0' + remainder; - } while (value != 0); - } - - /* Remember the end+1 and back up 'str' to the last character. */ - end = str--; - - /* Reverse string. */ - while (start < str) - { - char swap = *start; - - *start++ = *str; - *str-- = swap; - } - - return end; + return str + len; } /* diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h index a241af4bdf..e2016a8bc2 100644 --- a/src/include/utils/builtins.h +++ b/src/include/utils/builtins.h @@ -18,6 +18,8 @@ #include "nodes/nodes.h" #include "utils/fmgrprotos.h" +/* Sign + the most decimal digits an 8-byte number could have */ +#define MAXINT8LEN 20 /* bool.c */ extern bool parse_bool(const char *value, bool *result); @@ -46,10 +48,12 @@ extern int32 pg_atoi(const char *s, int size, int c); extern int16 pg_strtoint16(const char *s); extern int32 pg_strtoint32(const char *s); extern void pg_itoa(int16 i, char *a); +int pg_ultoa_n(uint32 l, char *a); +int pg_ulltoa_n(uint64 l, char *a); extern void pg_ltoa(int32 l, char *a); extern void pg_lltoa(int64 ll, char *a); -extern char *pg_ltostr_zeropad(char *str, int32 value, int32 minwidth); -extern char *pg_ltostr(char *str, int32 value); +extern char *pg_ultostr_zeropad(char *str, uint32 value, int32 minwidth); +extern char *pg_ultostr(char *str, uint32 value); extern uint64 pg_strtouint64(const char *str, char **endptr, int base); /* oid.c */