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);
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)
* 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;
}
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;
}
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;
/* 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;
}
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)
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)
/* 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);
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);
*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;
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)
#include "utils/builtins.h"
#include "utils/int8.h"
-#define MAXINT8LEN 25
typedef struct
{
#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
}
/*
- * 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.
* 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;
}
/*
* 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;
}
/*
#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);
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 */
projects / thirdparty / postgresql.git / commitdiff
