>> ... I'd put parts of out(print) function
>> refactor in the next 2 days. I think it deserves a double check before
>> working on *all* the out function.
>
> Well, sure. You *cannot* write a patch that breaks existing output
> functions. Not at the start, and not at the end either. You
> should focus on writing the infrastructure and, for starters,
> converting just a few output functions as a demonstration. If
> that gets accepted then you can work on converting other output
> functions a few at a time. But they'll never all be done, because
> we can't realistically force extensions to convert.
>
> There are lots of examples of similar incremental conversions in our
> project's history. I think the most recent example is the "soft error
> handling" work (d9f7f5d32, ccff2d20e, and many follow-on patches).
Thank you for this example! What I want is a smaller step than you said.
Our goal is to make out function take an extra StringInfo input to avoid
the extra palloc, memcpy, strlen. so the *final state* is:
1). implement all the out functions with (datum, StringInfo) as inputs.
2). change all the caller like printtup or any other function.
3). any extensions which doesn't in core has to change their out function
for their data type. The patch in this thread can't help in this area,
but I guess it would not be very hard for extension's author.
The current (intermediate) stage is:
- I finished parts of step (1), 17 functions in toally. and named it as
print function, the function body is exactly same as the out function in
final stage, so this part is reviewable.
- I use them in printtup user case. so it is testable (for correctness
and performance test purpose).
so I want some of you can have a double check on these function bodies, if
anything wrong, I can change it easlier (vs I made the same efforts on
all the type function). does it make sense?
Patch 0001 ~ 0003 is something related and can be reviewed or committed
seperately. and 0004 is the main part of the above.
--
Best Regards
Andy Fan
>From 4fa462d02902e7ac278a312ad60f43c52f403753 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1...@163.com>
Date: Wed, 11 Sep 2024 12:25:52 +0800
Subject: [PATCH v20240912 3/4] add unlikely hint for enlargeStringInfo.
enlargeStringInfo has a noticeable ratio in perf peport with a
"select * from pg_class" workload). So add a unlikely hint in
enlargeStringinfo to avoid some overhead.
---
src/common/stringinfo.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/common/stringinfo.c b/src/common/stringinfo.c
index eb9d6502fc..838d9b80d0 100644
--- a/src/common/stringinfo.c
+++ b/src/common/stringinfo.c
@@ -297,7 +297,7 @@ enlargeStringInfo(StringInfo str, int needed)
* Guard against out-of-range "needed" values. Without this, we can get
* an overflow or infinite loop in the following.
*/
- if (needed < 0) /* should not happen */
+ if (unlikely(needed < 0)) /* should not happen */
{
#ifndef FRONTEND
elog(ERROR, "invalid string enlargement request size: %d", needed);
@@ -306,7 +306,7 @@ enlargeStringInfo(StringInfo str, int needed)
exit(EXIT_FAILURE);
#endif
}
- if (((Size) needed) >= (MaxAllocSize - (Size) str->len))
+ if (unlikely(((Size) needed) >= (MaxAllocSize - (Size) str->len)))
{
#ifndef FRONTEND
ereport(ERROR,
--
2.45.1
>From dc1475195f1350745e45a5b7db381354f99d83da Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1...@163.com>
Date: Wed, 11 Sep 2024 12:19:57 +0800
Subject: [PATCH v20240912 1/4] Refactor float8out_internval for better
performance
Some users like cube, geo needs calls float8out_internval to get a
string, and then copy them into its own StringInfo. In this commit,
we would let the user provide a buffer to float8out_internal so that it
can put the data to buffer directly. This commit also reuse the existing
string length to avoid another strlen call in appendStringInfoString.
---
contrib/cube/cube.c | 17 +++++++++++++++--
src/backend/utils/adt/float.c | 14 ++++++++------
src/backend/utils/adt/geo_ops.c | 34 ++++++++++++++++++++++-----------
src/include/catalog/pg_type.h | 1 +
src/include/utils/float.h | 2 +-
5 files changed, 48 insertions(+), 20 deletions(-)
diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c
index 1fc447511a..a239acf35c 100644
--- a/contrib/cube/cube.c
+++ b/contrib/cube/cube.c
@@ -12,6 +12,7 @@
#include "access/gist.h"
#include "access/stratnum.h"
+#include "catalog/pg_type.h"
#include "cubedata.h"
#include "libpq/pqformat.h"
#include "utils/array.h"
@@ -295,26 +296,38 @@ cube_out(PG_FUNCTION_ARGS)
StringInfoData buf;
int dim = DIM(cube);
int i;
+ int str_len;
initStringInfo(&buf);
appendStringInfoChar(&buf, '(');
+
+ /* 3 for ", " and 1 for '\0'. */
+ enlargeStringInfo(&buf, (MAXFLOAT8LEN + 4) * dim);
for (i = 0; i < dim; i++)
{
if (i > 0)
appendStringInfoString(&buf, ", ");
- appendStringInfoString(&buf, float8out_internal(LL_COORD(cube, i)));
+ float8out_internal(LL_COORD(cube, i), buf.data + buf.len, &str_len);
+ buf.len += str_len;
+ buf.data[buf.len] = '\0';
}
appendStringInfoChar(&buf, ')');
if (!cube_is_point_internal(cube))
{
appendStringInfoString(&buf, ",(");
+
+ /* 3 for ", " and 1 for '\0'. */
+ enlargeStringInfo(&buf, (MAXFLOAT8LEN + 4) * dim);
for (i = 0; i < dim; i++)
{
if (i > 0)
appendStringInfoString(&buf, ", ");
- appendStringInfoString(&buf, float8out_internal(UR_COORD(cube, i)));
+
+ float8out_internal(UR_COORD(cube, i), buf.data + buf.len, &str_len);
+ buf.len += str_len;
+ buf.data[buf.len] = '\0';
}
appendStringInfoChar(&buf, ')');
}
diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c
index f709c21e1f..1f31f8540e 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -531,22 +531,24 @@ float8out(PG_FUNCTION_ARGS)
* float8out_internal - guts of float8out()
*
* This is exposed for use by functions that want a reasonably
- * platform-independent way of outputting doubles.
- * The result is always palloc'd.
+ * platform-independent way of outputting doubles, output the
+ * string length to *len;
*/
char *
-float8out_internal(double num)
+float8out_internal(double num, char *ascii, int *len)
{
- char *ascii = (char *) palloc(32);
int ndig = DBL_DIG + extra_float_digits;
+ if (ascii == NULL)
+ ascii = (char *) palloc(MAXFLOAT8LEN);
+
if (extra_float_digits > 0)
{
- double_to_shortest_decimal_buf(num, ascii);
+ *len = double_to_shortest_decimal_buf(num, ascii);
return ascii;
}
- (void) pg_strfromd(ascii, 32, ndig, num);
+ *len = pg_strfromd(ascii, 32, ndig, num);
return ascii;
}
diff --git a/src/backend/utils/adt/geo_ops.c b/src/backend/utils/adt/geo_ops.c
index 07d1649c7b..59f2feaa59 100644
--- a/src/backend/utils/adt/geo_ops.c
+++ b/src/backend/utils/adt/geo_ops.c
@@ -29,6 +29,7 @@
#include <float.h>
#include <ctype.h>
+#include "catalog/pg_type.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
@@ -202,10 +203,12 @@ single_decode(char *num, float8 *x, char **endptr_p,
static void
single_encode(float8 x, StringInfo str)
{
- char *xstr = float8out_internal(x);
+ int str_len;
+ enlargeStringInfo(str, MAXFLOAT8LEN + 1);
+ float8out_internal(x, str->data + str->len, &str_len);
- appendStringInfoString(str, xstr);
- pfree(xstr);
+ str->len += str_len;
+ str->data[str->len] = '\0';
} /* single_encode() */
static bool
@@ -254,12 +257,20 @@ fail:
static void
pair_encode(float8 x, float8 y, StringInfo str)
{
- char *xstr = float8out_internal(x);
- char *ystr = float8out_internal(y);
+ int data_len;
+ /* the additional 2 is for ',' and '\0' */
+ enlargeStringInfo(str, MAXFLOAT8LEN * 2 + 2);
- appendStringInfo(str, "%s,%s", xstr, ystr);
- pfree(xstr);
- pfree(ystr);
+ float8out_internal(x, str->data + str->len, &data_len);
+ str->len += data_len;
+
+ str->data[str->len] = ',';
+ str->len++;
+
+ float8out_internal(y, str->data + str->len, &data_len);
+ str->len += data_len;
+
+ str->data[str->len] = '\0';
}
static bool
@@ -1023,9 +1034,10 @@ Datum
line_out(PG_FUNCTION_ARGS)
{
LINE *line = PG_GETARG_LINE_P(0);
- char *astr = float8out_internal(line->A);
- char *bstr = float8out_internal(line->B);
- char *cstr = float8out_internal(line->C);
+ int datalen;
+ char *astr = float8out_internal(line->A, NULL, &datalen);
+ char *bstr = float8out_internal(line->B, NULL, &datalen);
+ char *cstr = float8out_internal(line->C, NULL, &datalen);
PG_RETURN_CSTRING(psprintf("%c%s%c%s%c%s%c", LDELIM_L, astr, DELIM, bstr,
DELIM, cstr, RDELIM_L));
diff --git a/src/include/catalog/pg_type.h b/src/include/catalog/pg_type.h
index e925969732..1ab8e4e4e9 100644
--- a/src/include/catalog/pg_type.h
+++ b/src/include/catalog/pg_type.h
@@ -344,6 +344,7 @@ MAKE_SYSCACHE(TYPENAMENSP, pg_type_typname_nsp_index, 64);
#endif /* EXPOSE_TO_CLIENT_CODE */
+#define MAXFLOAT8LEN 32
extern ObjectAddress TypeShellMake(const char *typeName,
Oid typeNamespace,
diff --git a/src/include/utils/float.h b/src/include/utils/float.h
index 7d1badd292..65c395299d 100644
--- a/src/include/utils/float.h
+++ b/src/include/utils/float.h
@@ -47,7 +47,7 @@ extern float8 float8in_internal(char *num, char **endptr_p,
extern float4 float4in_internal(char *num, char **endptr_p,
const char *type_name, const char *orig_string,
struct Node *escontext);
-extern char *float8out_internal(float8 num);
+extern char *float8out_internal(float8 num, char *ascii, int *len);
extern int float4_cmp_internal(float4 a, float4 b);
extern int float8_cmp_internal(float8 a, float8 b);
--
2.45.1
>From 8b4ba05a9c0e767c1d053365e70966e1d9544179 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1...@163.com>
Date: Wed, 11 Sep 2024 12:21:39 +0800
Subject: [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
>From bbeb539f85c80ffe44f71c12aabd725c8b29ead4 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1...@163.com>
Date: Thu, 12 Sep 2024 10:03:57 +0000
Subject: [PATCH v20240912 4/4] Make printtup a bit faster (intermediate
state).
Currently the out function usually allocate its own memory and fill it
with the cstring. After the printtup get the cstring, printtup computes
it string length and copy it to its own StringInfo. So there are some
wastage in this workflow.
In the desired case, out function should take a StringInfo as a input
and fill the data to StringInfo's buffer directly. Within this way,
there is no extra memory allocate, memory copy and probably avoid the
most strlen since the most of the outfunction can compute it easily. for
example a). snprintf return the length encoded string, b). the varlena's
header has a strlen. c). we know the start position before we encode a
Datum and we know the end position after the Datum encoding, so the
length would be similar as 'end_pos - start_pos'.
Since we have 79 out functions to change, this patch just finish part of
them by using a new print function and wish a review of it. If there are
anything wrong, it is better know them earlier.
---
src/backend/access/common/printtup.c | 80 ++++++++++++++++++--
src/backend/utils/adt/char.c | 32 ++++++++
src/backend/utils/adt/date.c | 74 ++++++++++++++++++-
src/backend/utils/adt/datetime.c | 17 ++++-
src/backend/utils/adt/float.c | 53 +++++++++++++-
src/backend/utils/adt/int.c | 32 ++++++++
src/backend/utils/adt/int8.c | 16 ++++
src/backend/utils/adt/numeric.c | 68 +++++++++++++++--
src/backend/utils/adt/oid.c | 16 ++++
src/backend/utils/adt/timestamp.c | 106 ++++++++++++++++++++++++++-
src/backend/utils/adt/varchar.c | 25 +++++++
src/backend/utils/adt/varlena.c | 16 ++++
src/include/catalog/pg_proc.dat | 83 ++++++++++++++++++++-
src/include/lib/stringinfo.h | 19 +++++
src/include/utils/date.h | 2 +-
src/include/utils/datetime.h | 8 +-
16 files changed, 618 insertions(+), 29 deletions(-)
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index c78cc39308..05f2f76b77 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -19,6 +19,7 @@
#include "libpq/pqformat.h"
#include "libpq/protocol.h"
#include "tcop/pquery.h"
+#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"
@@ -49,6 +50,7 @@ typedef struct
bool typisvarlena; /* is it varlena (ie possibly toastable)? */
int16 format; /* format code for this column */
FmgrInfo finfo; /* Precomputed call info for output fn */
+ FmgrInfo p_finfo; /* Precomputed call info for print fn if any */
} PrinttupAttrInfo;
typedef struct
@@ -243,6 +245,47 @@ SendRowDescriptionMessage(StringInfo buf, TupleDesc typeinfo,
pq_endmessage_reuse(buf);
}
+static Oid
+get_type_printfn_tmp(Oid type)
+{
+ switch(type)
+ {
+ case OIDOID:
+ return F_OIDPRINT;
+ case TEXTOID:
+ return F_TEXTPRINT;
+ case FLOAT4OID:
+ return F_FLOAT4PRINT;
+ case FLOAT8OID:
+ return F_FLOAT8PRINT;
+ case INT2OID:
+ return F_INT2PRINT;
+ case INT4OID:
+ return F_INT4PRINT;
+ case INT8OID:
+ return F_INT8PRINT;
+ case TIMEOID:
+ return F_TIMEPRINT;
+ case TIMETZOID:
+ return F_TIMETZPRINT;
+ case TIMESTAMPOID:
+ return F_TIMESTAMPPRINT;
+ case TIMESTAMPTZOID:
+ return F_TIMESTAMPTZPRINT;
+ case INTERVALOID:
+ return F_INTERVAL_PRINT;
+ case NUMERICOID:
+ return F_NUMERIC_PRINT;
+ case BPCHAROID:
+ return F_BPCHARPRINT;
+ case VARCHAROID:
+ return F_VARCHARPRINT;
+ case CHAROID:
+ return F_CHARPRINT;
+ }
+ return InvalidOid;
+}
+
/*
* Get the lookup info that printtup() needs
*/
@@ -274,10 +317,18 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
thisState->format = format;
if (format == 0)
{
- getTypeOutputInfo(attr->atttypid,
- &thisState->typoutput,
- &thisState->typisvarlena);
- fmgr_info(thisState->typoutput, &thisState->finfo);
+ Oid print_fn = get_type_printfn_tmp(attr->atttypid);
+ if (print_fn != InvalidOid)
+ fmgr_info(print_fn, &thisState->p_finfo);
+ else
+ {
+ getTypeOutputInfo(attr->atttypid,
+ &thisState->typoutput,
+ &thisState->typisvarlena);
+ fmgr_info(thisState->typoutput, &thisState->finfo);
+ /* mark print function is invalid */
+ thisState->p_finfo.fn_oid = InvalidOid;
+ }
}
else if (format == 1)
{
@@ -355,10 +406,23 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
if (thisState->format == 0)
{
/* Text output */
- char *outputstr;
-
- outputstr = OutputFunctionCall(&thisState->finfo, attr);
- pq_sendcountedtext(buf, outputstr, strlen(outputstr));
+ if (thisState->p_finfo.fn_oid)
+ {
+ /*
+ * Use print function if it is defined.
+ *
+ * XXX: we can remove this if statement once we refactor all
+ * the out function.
+ */
+ FunctionCall2(&thisState->p_finfo, attr, PointerGetDatum(buf));
+ }
+ else
+ {
+ char *outputstr;
+
+ outputstr = OutputFunctionCall(&thisState->finfo, attr);
+ pq_sendcountedtext(buf, outputstr, strlen(outputstr));
+ }
}
else
{
diff --git a/src/backend/utils/adt/char.c b/src/backend/utils/adt/char.c
index 5ee94be0d1..e9f8ba8cf3 100644
--- a/src/backend/utils/adt/char.c
+++ b/src/backend/utils/adt/char.c
@@ -83,6 +83,38 @@ charout(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+charprint(PG_FUNCTION_ARGS)
+{
+ char ch = PG_GETARG_CHAR(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ char *result;
+ uint32 data_len;
+
+ result = outStringReserveLen(buf, 5);
+
+ if (IS_HIGHBIT_SET(ch))
+ {
+ result[0] = '\\';
+ result[1] = TOOCTAL(((unsigned char) ch) >> 6);
+ result[2] = TOOCTAL((((unsigned char) ch) >> 3) & 07);
+ result[3] = TOOCTAL(((unsigned char) ch) & 07);
+ result[4] = '\0';
+ data_len = 4;
+ }
+ else
+ {
+ /* This produces acceptable results for 0x00 as well */
+ result[0] = ch;
+ result[1] = '\0';
+ data_len = 1;
+ }
+
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* charrecv - converts external binary format to char
*
diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 9c854e0e5c..4f5c939d2a 100644
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -202,6 +202,31 @@ date_out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+date_print(PG_FUNCTION_ARGS)
+{
+ DateADT date = PG_GETARG_DATEADT(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ char *data;
+ uint32 data_len;
+
+ struct pg_tm tt,
+ *tm = &tt;
+
+ data = outStringReserveLen(buf, MAXDATELEN + 1);
+
+ if (DATE_NOT_FINITE(date))
+ data_len = EncodeSpecialDate(date, data);
+ else
+ {
+ j2date(date + POSTGRES_EPOCH_JDATE,
+ &(tm->tm_year), &(tm->tm_mon), &(tm->tm_mday));
+ data_len = EncodeDateOnly(tm, DateStyle, data);
+ }
+ outStringCompletePhase(buf, data_len);
+ PG_RETURN_VOID();
+}
+
/*
* date_recv - converts external binary format to date
*/
@@ -290,13 +315,21 @@ make_date(PG_FUNCTION_ARGS)
/*
* Convert reserved date values to string.
*/
-void
+int
EncodeSpecialDate(DateADT dt, char *str)
{
if (DATE_IS_NOBEGIN(dt))
+ {
strcpy(str, EARLY);
+ /* the return value can be computed at compiling time. */
+ return strlen(EARLY);
+ }
else if (DATE_IS_NOEND(dt))
+ {
strcpy(str, LATE);
+ /* the return value can be computed at compiling time. */
+ return strlen(LATE);
+ }
else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialDate");
}
@@ -1514,6 +1547,25 @@ time_out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+time_print(PG_FUNCTION_ARGS)
+{
+ TimeADT time = PG_GETARG_TIMEADT(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ struct pg_tm tt,
+ *tm = &tt;
+ fsec_t fsec;
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, MAXDATELEN + 1);
+ time2tm(time, tm, &fsec);
+ data_len = EncodeTimeOnly(tm, fsec, false, 0, DateStyle, data);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* time_recv - converts external binary format to time
*/
@@ -2328,6 +2380,26 @@ timetz_out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+timetz_print(PG_FUNCTION_ARGS)
+{
+ TimeTzADT *time = PG_GETARG_TIMETZADT_P(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ struct pg_tm tt,
+ *tm = &tt;
+ fsec_t fsec;
+ char *data;
+ uint32 data_len;
+ int tz;
+
+ data = outStringReserveLen(buf, MAXDATELEN + 1);
+ timetz2tm(time, tm, &fsec, &tz);
+ data_len = EncodeTimeOnly(tm, fsec, true, tz, DateStyle, data);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* timetz_recv - converts external binary format to timetz
*/
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 586bec8466..a6ee310c52 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4223,9 +4223,10 @@ EncodeTimezone(char *str, int tz, int style)
/* EncodeDateOnly()
* Encode date as local time.
*/
-void
+int
EncodeDateOnly(struct pg_tm *tm, int style, char *str)
{
+ char *start = str;
Assert(tm->tm_mon >= 1 && tm->tm_mon <= MONTHS_PER_YEAR);
switch (style)
@@ -4297,6 +4298,7 @@ EncodeDateOnly(struct pg_tm *tm, int style, char *str)
str += 3;
}
*str = '\0';
+ return str - start;
}
@@ -4307,10 +4309,13 @@ EncodeDateOnly(struct pg_tm *tm, int style, char *str)
* a time zone (the difference between time and timetz types), tz is the
* numeric time zone offset, style is the date style, str is where to write the
* output.
+ *
+ * returns the strlen of the encoded format.
*/
-void
+int
EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style, char *str)
{
+ char *start = str;
str = pg_ultostr_zeropad(str, tm->tm_hour, 2);
*str++ = ':';
str = pg_ultostr_zeropad(str, tm->tm_min, 2);
@@ -4319,6 +4324,7 @@ EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style,
if (print_tz)
str = EncodeTimezone(str, tz, style);
*str = '\0';
+ return str - start;
}
@@ -4337,11 +4343,14 @@ EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style,
* ISO - yyyy-mm-dd hh:mm:ss+/-tz
* German - dd.mm.yyyy hh:mm:ss tz
* XSD - yyyy-mm-ddThh:mm:ss.ss+/-tz
+ *
+ * return the strlen of the encoded data.
*/
-void
+int
EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str)
{
int day;
+ char *start = str;
Assert(tm->tm_mon >= 1 && tm->tm_mon <= MONTHS_PER_YEAR);
@@ -4501,6 +4510,8 @@ EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char
str += 3;
}
*str = '\0';
+
+ return str - start;
}
diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c
index 1f31f8540e..54ea40c1ef 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -333,6 +333,32 @@ float4out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(ascii);
}
+
+Datum
+float4print(PG_FUNCTION_ARGS)
+{
+ float4 num = PG_GETARG_FLOAT4(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ int data_len;
+ char *ascii;
+ int ndig = FLT_DIG + extra_float_digits;
+
+ ascii = outStringReserveLen(buf, 32);
+
+ if (extra_float_digits > 0)
+ data_len = float_to_shortest_decimal_buf(num, ascii);
+ else
+ data_len = pg_strfromd(ascii, 32, ndig, num);
+ if (data_len == -1)
+ {
+ /* XXX, think more of this. */
+ elog(ERROR, "failed on float4print");
+ }
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* float4recv - converts external binary format to float4
*/
@@ -523,10 +549,35 @@ Datum
float8out(PG_FUNCTION_ARGS)
{
float8 num = PG_GETARG_FLOAT8(0);
+ int len;
- PG_RETURN_CSTRING(float8out_internal(num));
+ PG_RETURN_CSTRING(float8out_internal(num, NULL, &len));
}
+Datum
+float8print(PG_FUNCTION_ARGS)
+{
+ float8 num = PG_GETARG_FLOAT8(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ int data_len;
+ char *ascii;
+
+ ascii = outStringReserveLen(buf, 32);
+
+ float8out_internal(num, ascii, &data_len);
+
+ if (data_len == -1)
+ {
+ /* XXX, think more of this. */
+ elog(ERROR, "failed on float8print");
+ }
+
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
+
/*
* float8out_internal - guts of float8out()
*
diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
index 234f20796b..8a7a184885 100644
--- a/src/backend/utils/adt/int.c
+++ b/src/backend/utils/adt/int.c
@@ -80,6 +80,22 @@ int2out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+
+Datum
+int2print(PG_FUNCTION_ARGS)
+{
+ int16 arg1 = PG_GETARG_INT16(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, 7);
+ data_len = pg_itoa(arg1, data);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* int2recv - converts external binary format to int2
*/
@@ -304,6 +320,22 @@ int4out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+int4print(PG_FUNCTION_ARGS)
+{
+ int32 arg1 = PG_GETARG_INT32(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, 12);
+ data_len = pg_ltoa(arg1, data);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
+
/*
* int4recv - converts external binary format to int4
*/
diff --git a/src/backend/utils/adt/int8.c b/src/backend/utils/adt/int8.c
index 54fa3bc379..a2e575ca5f 100644
--- a/src/backend/utils/adt/int8.c
+++ b/src/backend/utils/adt/int8.c
@@ -76,6 +76,22 @@ int8out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+int8print(PG_FUNCTION_ARGS)
+{
+ int64 arg1 = PG_GETARG_INT64(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, MAXINT8LEN + 1);
+ data_len = pg_lltoa(arg1, data);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
+
/*
* int8recv - converts external binary format to int8
*/
diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 15b517ba98..68635ac74f 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -516,7 +516,7 @@ static bool set_var_from_non_decimal_integer_str(const char *str,
static void set_var_from_num(Numeric num, NumericVar *dest);
static void init_var_from_num(Numeric num, NumericVar *dest);
static void set_var_from_var(const NumericVar *value, NumericVar *dest);
-static char *get_str_from_var(const NumericVar *var);
+static char *get_str_from_var(const NumericVar *var, StringInfo buf);
static char *get_str_from_var_sci(const NumericVar *var, int rscale);
static void numericvar_serialize(StringInfo buf, const NumericVar *var);
@@ -839,11 +839,52 @@ numeric_out(PG_FUNCTION_ARGS)
*/
init_var_from_num(num, &x);
- str = get_str_from_var(&x);
+ str = get_str_from_var(&x, NULL);
PG_RETURN_CSTRING(str);
}
+Datum
+numeric_print(PG_FUNCTION_ARGS)
+{
+ Numeric num = PG_GETARG_NUMERIC(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+
+ NumericVar x;
+
+ /*
+ * Handle NaN and infinities
+ */
+ if (NUMERIC_IS_SPECIAL(num))
+ {
+ const char* special_str;
+ char *data;
+ uint32 data_len;
+
+ if (NUMERIC_IS_PINF(num))
+ special_str = "Infinity";
+ else if (NUMERIC_IS_NINF(num))
+ special_str = "-Infinity";
+ else
+ special_str = "NaN";
+
+ data_len = strlen(special_str) + 1;
+ data = outStringReserveLen(buf, data_len);
+ memcpy(data, special_str, data_len);
+ outStringCompletePhase(buf, data_len);
+ PG_RETURN_VOID();
+ }
+
+ /*
+ * Get the number in the variable format.
+ */
+ init_var_from_num(num, &x);
+
+ (void) get_str_from_var(&x, buf);
+
+ PG_RETURN_VOID();
+}
+
/*
* numeric_is_nan() -
*
@@ -1046,7 +1087,7 @@ numeric_normalize(Numeric num)
init_var_from_num(num, &x);
- str = get_str_from_var(&x);
+ str = get_str_from_var(&x, NULL);
/* If there's no decimal point, there's certainly nothing to remove. */
if (strchr(str, '.') != NULL)
@@ -7491,7 +7532,7 @@ set_var_from_var(const NumericVar *value, NumericVar *dest)
* Returns a palloc'd string.
*/
static char *
-get_str_from_var(const NumericVar *var)
+get_str_from_var(const NumericVar *var, StringInfo buf)
{
int dscale;
char *str;
@@ -7519,7 +7560,14 @@ get_str_from_var(const NumericVar *var)
if (i <= 0)
i = 1;
- str = palloc(i + dscale + DEC_DIGITS + 2);
+ if (buf == NULL)
+ {
+ str = palloc(i + dscale + DEC_DIGITS + 2);
+ }
+ else
+ {
+ str = outStringReserveLen(buf, i + dscale + DEC_DIGITS + 2);
+ }
cp = str;
/*
@@ -7618,6 +7666,12 @@ get_str_from_var(const NumericVar *var)
* terminate the string and return it
*/
*cp = '\0';
+
+ if (buf != NULL)
+ {
+ uint32 data_len = cp - str;
+ outStringCompletePhase(buf, data_len);
+ }
return str;
}
@@ -7691,7 +7745,7 @@ get_str_from_var_sci(const NumericVar *var, int rscale)
power_ten_int(exponent, &tmp_var);
div_var(var, &tmp_var, &tmp_var, rscale, true);
- sig_out = get_str_from_var(&tmp_var);
+ sig_out = get_str_from_var(&tmp_var, NULL);
free_var(&tmp_var);
@@ -8344,7 +8398,7 @@ numericvar_to_double_no_overflow(const NumericVar *var)
double val;
char *endptr;
- tmp = get_str_from_var(var);
+ tmp = get_str_from_var(var, NULL);
/* unlike float8in, we ignore ERANGE from strtod */
val = strtod(tmp, &endptr);
diff --git a/src/backend/utils/adt/oid.c b/src/backend/utils/adt/oid.c
index 56fb1fd77c..db34d9b6ea 100644
--- a/src/backend/utils/adt/oid.c
+++ b/src/backend/utils/adt/oid.c
@@ -53,6 +53,22 @@ oidout(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+oidprint(PG_FUNCTION_ARGS)
+{
+ Oid o = PG_GETARG_OID(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ uint32 data_len;
+ char *data;
+
+ /* 12 is the max length for an oid's text presentation. */
+ data = outStringReserveLen(buf, 12);
+ data_len = pg_snprintf(data, 12, "%u", o);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* oidrecv - converts external binary format to oid
*/
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index db9eea9098..9068682bca 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -95,7 +95,7 @@ static bool AdjustIntervalForTypmod(Interval *interval, int32 typmod,
static TimestampTz timestamp2timestamptz(Timestamp timestamp);
static Timestamp timestamptz2timestamp(TimestampTz timestamp);
-static void EncodeSpecialInterval(const Interval *interval, char *str);
+static int EncodeSpecialInterval(const Interval *interval, char *str);
static void interval_um_internal(const Interval *interval, Interval *result);
/* common code for timestamptypmodin and timestamptztypmodin */
@@ -252,6 +252,33 @@ timestamp_out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+timestamp_print(PG_FUNCTION_ARGS)
+{
+ Timestamp timestamp = PG_GETARG_TIMESTAMP(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ struct pg_tm tt,
+ *tm = &tt;
+ fsec_t fsec;
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, MAXDATELEN + 1);
+
+ if (TIMESTAMP_NOT_FINITE(timestamp))
+ data_len = EncodeSpecialTimestamp(timestamp, data);
+ else if (timestamp2tm(timestamp, NULL, tm, &fsec, NULL, NULL) == 0)
+ data_len = EncodeDateTime(tm, fsec, false, 0, NULL, DateStyle, data);
+ else
+ ereport(ERROR,
+ (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+ errmsg("timestamp out of range")));
+
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* timestamp_recv - converts external binary format to timestamp
*/
@@ -796,6 +823,36 @@ timestamptz_out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+timestamptz_print(PG_FUNCTION_ARGS)
+{
+ TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ int tz;
+ const char *tzn;
+ struct pg_tm tt,
+ *tm = &tt;
+ fsec_t fsec;
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, MAXDATELEN + 1);
+
+ if (TIMESTAMP_NOT_FINITE(timestamp))
+ data_len = EncodeSpecialTimestamp(timestamp, data);
+ else if (timestamp2tm(timestamp, &tz, tm, &fsec, &tzn, NULL) == 0)
+ data_len = EncodeDateTime(tm, fsec, true, tz, tzn, DateStyle, data);
+ else
+ ereport(ERROR,
+ (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+ errmsg("timestamp out of range")));
+
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
+
/*
* timestamptz_recv - converts external binary format to timestamptz
*/
@@ -989,6 +1046,35 @@ interval_out(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(result);
}
+Datum
+interval_print(PG_FUNCTION_ARGS)
+{
+ Interval *span = PG_GETARG_INTERVAL_P(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ struct pg_itm tt,
+ *itm = &tt;
+ char *data;
+ uint32 data_len;
+
+ data = outStringReserveLen(buf, MAXDATELEN + 1);
+
+ if (INTERVAL_NOT_FINITE(span))
+ data_len = EncodeSpecialInterval(span, data);
+ else
+ {
+ interval2itm(*span, itm);
+ EncodeInterval(itm, IntervalStyle, data);
+ /*
+ * XXX: making EncodeInterval returns a string len is error-prone for me.
+ * so call strlen directly on the result.
+ */
+ data_len = strlen(data);
+ }
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* interval_recv - converts external binary format to interval
*/
@@ -1582,26 +1668,40 @@ out_of_range:
/* EncodeSpecialTimestamp()
* Convert reserved timestamp data type to string.
*/
-void
+int
EncodeSpecialTimestamp(Timestamp dt, char *str)
{
if (TIMESTAMP_IS_NOBEGIN(dt))
+ {
strcpy(str, EARLY);
+ return strlen(EARLY);
+ }
else if (TIMESTAMP_IS_NOEND(dt))
+ {
strcpy(str, LATE);
+ return strlen(LATE);
+ }
else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialTimestamp");
}
-static void
+static int
EncodeSpecialInterval(const Interval *interval, char *str)
{
if (INTERVAL_IS_NOBEGIN(interval))
+ {
strcpy(str, EARLY);
+ return strlen(EARLY);
+ }
else if (INTERVAL_IS_NOEND(interval))
+ {
strcpy(str, LATE);
+ return strlen(LATE);
+ }
else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialInterval");
+
+ return 0;
}
Datum
diff --git a/src/backend/utils/adt/varchar.c b/src/backend/utils/adt/varchar.c
index 0c219dcc77..db4cc7c3ef 100644
--- a/src/backend/utils/adt/varchar.c
+++ b/src/backend/utils/adt/varchar.c
@@ -223,6 +223,25 @@ bpcharout(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(TextDatumGetCString(txt));
}
+Datum
+bpcharprint(PG_FUNCTION_ARGS)
+{
+ Datum txt = PG_GETARG_DATUM(0);
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+
+ /* XXX: improve here since we can put the cstring into buf directly. */
+ char *data = TextDatumGetCString(txt);
+ uint32 data_len = strlen(data);
+ char *target;
+
+ target = outStringReserveLen(buf, data_len);
+ memcpy(target, data, data_len);
+ outStringCompletePhase(buf, data_len);
+
+ PG_RETURN_VOID();
+}
+
+
/*
* bpcharrecv - converts external binary format to bpchar
*/
@@ -520,6 +539,12 @@ varcharout(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(TextDatumGetCString(txt));
}
+Datum
+varcharprint(PG_FUNCTION_ARGS)
+{
+ return bpcharprint(fcinfo);
+}
+
/*
* varcharrecv - converts external binary format to varchar
*/
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index 7c6391a276..488d770bd2 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -594,6 +594,22 @@ textout(PG_FUNCTION_ARGS)
PG_RETURN_CSTRING(TextDatumGetCString(txt));
}
+
+Datum
+textprint(PG_FUNCTION_ARGS)
+{
+ text *txt = (text *) pg_detoast_datum((struct varlena *)PG_GETARG_POINTER(0));
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(1);
+ uint32 text_len = VARSIZE(txt) - VARHDRSZ;
+ char *data;
+
+ data = outStringReserveLen(buf, text_len);
+ memcpy(data, VARDATA(txt), text_len);
+ outStringCompletePhase(buf, text_len);
+
+ PG_RETURN_VOID();
+}
+
/*
* textrecv - converts external binary format to text
*/
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 85f42be1b3..ab251a653b 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -4718,7 +4718,6 @@
{ oid => '1799', descr => 'I/O',
proname => 'oidout', prorettype => 'cstring', proargtypes => 'oid',
prosrc => 'oidout' },
-
{ oid => '3058', descr => 'concatenate values',
proname => 'concat', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'text', proargtypes => 'any',
@@ -12255,4 +12254,86 @@
proargnames => '{summarized_tli,summarized_lsn,pending_lsn,summarizer_pid}',
prosrc => 'pg_get_wal_summarizer_state' },
+{
+ oid => '9771', descr => 'I/O',
+ proname => 'oidprint', prorettype => 'void', proargtypes => 'oid internal',
+ prosrc => 'oidprint'},
+{
+ oid => '8907', descr => 'I/O',
+ proname => 'textprint', prorettype => 'void', proargtypes => 'text internal',
+ prosrc => 'textprint' },
+
+{
+ oid => '9234', descr => 'I/O',
+ proname => 'float4print', prorettype => 'void', proargtypes => 'float4 internal',
+ prosrc => 'float4print' },
+{
+ oid => '6313', descr => 'I/O',
+ proname => 'float8print', prorettype => 'void', proargtypes => 'float8 internal',
+ prosrc => 'float8print' },
+
+{
+ oid => '4099', descr => 'I/O',
+ proname => 'int2print', prorettype => 'void', proargtypes => 'int2 internal',
+ prosrc => 'int2print' },
+{
+ oid => '4100', descr => 'I/O',
+ proname => 'int4print', prorettype => 'void', proargtypes => 'int4 internal',
+ prosrc => 'int4print' },
+{
+ oid => '4551', descr => 'I/O',
+ proname => 'int8print', prorettype => 'void', proargtypes => 'int8 internal',
+ prosrc => 'int8print' },
+
+{
+ oid => '4552', descr => 'I/O',
+ proname => 'timeprint', prorettype => 'void', proargtypes => 'time internal',
+ prosrc => 'time_print' },
+
+{
+ oid => '4553', descr => 'I/O',
+ proname => 'timetzprint', prorettype => 'void', proargtypes => 'timetz internal',
+ prosrc => 'timetz_print' },
+
+{
+ oid => '4554', descr => 'I/O',
+ proname => 'dateprint', prorettype => 'void', proargtypes => 'date internal',
+ prosrc => 'date_print'},
+
+
+{
+ oid => '4555', descr => 'I/O',
+ proname => 'timestampprint', prorettype => 'void', proargtypes => 'timestamp internal',
+ prosrc => 'timestamp_print'},
+
+{
+ oid => '4556', descr => 'I/O',
+ proname => 'timestamptzprint', prorettype => 'void', proargtypes => 'timestamptz internal',
+ prosrc => 'timestamptz_print'},
+
+{
+ oid => '4557', descr => 'I/O',
+ proname => 'interval_print', prorettype => 'void', proargtypes => 'interval internal',
+ prosrc => 'interval_print'},
+
+{
+ oid => '4558', descr => 'I/O',
+ proname => 'numeric_print', prorettype => 'void', proargtypes => 'numeric internal',
+ prosrc => 'numeric_print'},
+
+{
+ oid => '4559', descr => 'I/O',
+ proname => 'charprint', prorettype => 'void', proargtypes => 'char internal',
+ prosrc => 'charprint'},
+
+{
+ oid => '4560', descr => 'I/O',
+ proname => 'bpcharprint', prorettype => 'void', proargtypes => 'bpchar internal',
+ prosrc => 'bpcharprint'},
+
+{
+ oid => '4561', descr => 'I/O',
+ proname => 'varcharprint', prorettype => 'void', proargtypes => 'varchar internal',
+ prosrc => 'varcharprint'},
+
]
diff --git a/src/include/lib/stringinfo.h b/src/include/lib/stringinfo.h
index cd9632e3fc..893a7825a2 100644
--- a/src/include/lib/stringinfo.h
+++ b/src/include/lib/stringinfo.h
@@ -240,4 +240,23 @@ extern void enlargeStringInfo(StringInfo str, int needed);
*/
extern void destroyStringInfo(StringInfo str);
+/*
+ * outString - The StringInfo used in type specific out function.
+ */
+static inline char *
+outStringReserveLen(StringInfo buf, uint32 data_len)
+{
+ /* sizeof(uint32) is for storing the data_len itself. */
+ enlargeStringInfo(buf, sizeof(uint32) + data_len);
+ return buf->data + buf->len + sizeof(uint32);
+}
+
+/* define outStringCompletePhase as macro to avoid including pg_bswap.h */
+#define outStringCompletePhase(buf, data_len) \
+{ \
+ *(uint32 *)(buf->data + buf->len) = pg_hton32(data_len); \
+ buf->len += sizeof(uint32) + data_len; \
+}
+
+
#endif /* STRINGINFO_H */
diff --git a/src/include/utils/date.h b/src/include/utils/date.h
index aaed6471a6..5fe73d29da 100644
--- a/src/include/utils/date.h
+++ b/src/include/utils/date.h
@@ -103,7 +103,7 @@ extern TimestampTz date2timestamptz_opt_overflow(DateADT dateVal, int *overflow)
extern int32 date_cmp_timestamp_internal(DateADT dateVal, Timestamp dt2);
extern int32 date_cmp_timestamptz_internal(DateADT dateVal, TimestampTz dt2);
-extern void EncodeSpecialDate(DateADT dt, char *str);
+extern int EncodeSpecialDate(DateADT dt, char *str);
extern DateADT GetSQLCurrentDate(void);
extern TimeTzADT *GetSQLCurrentTime(int32 typmod);
extern TimeADT GetSQLLocalTime(int32 typmod);
diff --git a/src/include/utils/datetime.h b/src/include/utils/datetime.h
index e4ac2b8e7f..9d994fd851 100644
--- a/src/include/utils/datetime.h
+++ b/src/include/utils/datetime.h
@@ -330,11 +330,11 @@ extern int DetermineTimeZoneAbbrevOffset(struct pg_tm *tm, const char *abbr, pg_
extern int DetermineTimeZoneAbbrevOffsetTS(TimestampTz ts, const char *abbr,
pg_tz *tzp, int *isdst);
-extern void EncodeDateOnly(struct pg_tm *tm, int style, char *str);
-extern void EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style, char *str);
-extern void EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str);
+extern int EncodeDateOnly(struct pg_tm *tm, int style, char *str);
+extern int EncodeTimeOnly(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, int style, char *str);
+extern int EncodeDateTime(struct pg_tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str);
extern void EncodeInterval(struct pg_itm *itm, int style, char *str);
-extern void EncodeSpecialTimestamp(Timestamp dt, char *str);
+extern int EncodeSpecialTimestamp(Timestamp dt, char *str);
extern int ValidateDate(int fmask, bool isjulian, bool is2digits, bool bc,
struct pg_tm *tm);
--
2.45.1
