open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Optimizations for integer to decimal output.

Browse Source 
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
pull/49/head
Andrew Gierth 6 years ago
parent 7bae0ad9fc
commit 1fd687a035
5 changed files with 287 additions and 227 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      src/backend/access/common/printsimple.c
  2. 98
      src/backend/utils/adt/datetime.c
  3. 1
      src/backend/utils/adt/int8.c
  4. 405
      src/backend/utils/adt/numutils.c
  5. 8
      src/include/utils/builtins.h

2
src/backend/access/common/printsimple.c
Unescape View File

@ -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);

98
src/backend/utils/adt/datetime.c
Unescape View File

@ -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)

1
src/backend/utils/adt/int8.c
Unescape View File

@ -26,7 +26,6 @@
#include "utils/builtins.h"
#include "utils/int8.h"
#define MAXINT8LEN 25
typedef struct
{

405
src/backend/utils/adt/numutils.c
Unescape View File

@ -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)
*/
void
pg_ltoa(int32 value, char *a)
int
pg_ultoa_n(uint32 value, char *a)
{
char *start = a;
bool neg = false;
int olength,
i = 0;
/*
* Avoid problems with the most negative integer not being representable
* as a positive integer.
*/
if (value == PG_INT32_MIN)
{
memcpy(a, "-2147483648", 12);
return;
}
else if (value < 0)
/* Degenerate case */
if (value == 0)
{
value = -value;
neg = true;
*a = '0';
return 1;
}
/* Compute the result string backwards. */
do
olength = decimalLength32(value);
/* Compute the result string. */
while (value >= 10000)
{
int32 remainder;
int32 oldval = value;
const uint32 c = value - 10000 * (value / 10000);
const uint32 c0 = (c % 100) << 1;
const uint32 c1 = (c / 100) << 1;
value /= 10;
remainder = oldval - value * 10;
*a++ = '0' + remainder;
} while (value != 0);
char *pos = a + olength - i;
if (neg)
*a++ = '-';
value /= 10000;
/* Add trailing NUL byte, and back up 'a' to the last character. */
*a-- = '\0';
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;
/* Reverse string. */
while (start < a)
memcpy(pos - 2, DIGIT_TABLE + c, 2);
i += 2;
}
if (value >= 10)
{
char swap = *start;
const uint32 c = value << 1;
char *pos = a + olength - i;
*start++ = *a;
*a-- = swap;
memcpy(pos - 2, DIGIT_TABLE + c, 2);
}
else
{
*a = (char) ('0' + value);
}
return olength;
}
/*
* pg_lltoa: convert a signed 64-bit integer to its string representation
* NUL-terminate the output of pg_ultoa_n.
*
* 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).
* 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_lltoa(int64 value, char *a)
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_INT64_MIN)
uint32 uvalue = (uint32) value;
int len;
if (value < 0)
{
memcpy(a, "-9223372036854775808", 21);
return;
uvalue = (uint32) 0 - uvalue;
*a++ = '-';
}
else if (value < 0)
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)
{
value = -value;
neg = true;
*a = '0';
return 1;
}
/* Compute the result string backwards. */
do
olength = decimalLength64(value);
/* Compute the result string. */
while (value >= 100000000)
{
int64 remainder;
int64 oldval = value;
const uint64 q = value / 100000000;
uint32 value2 = (uint32) (value - 100000000 * q);
value /= 10;
remainder = oldval - value * 10;
*a++ = '0' + remainder;
} while (value != 0);
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;
if (neg)
*a++ = '-';
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;
/* Add trailing NUL byte, and back up 'a' to the last character. */
*a-- = '\0';
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;
/* Reverse string. */
while (start < a)
value2 /= 10000;
memcpy(pos - 2, DIGIT_TABLE + c0, 2);
memcpy(pos - 4, DIGIT_TABLE + c1, 2);
i += 4;
}
if (value2 >= 100)
{
char swap = *start;
const uint32 c = (value2 % 100) << 1;
char *pos = a + olength - i;
*start++ = *a;
*a-- = swap;
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).
*/
void
pg_lltoa(int64 value, char *a)
{
int len;
uint64 uvalue = value;
if (value < 0)
{
*a++ = '-';
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;
/*
* 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;
}
int len = pg_ultoa_n(value, str);
return end;
return str + len;
}
/*

8
src/include/utils/builtins.h
Unescape View File

@ -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 */

Write Preview
Loading…
Cancel
Save