agora inbox for pgsql-hackers@postgresql.org
help / color / mirror / Atom feedMake printtup a bit faster
24+ messages / 5 participants
[nested] [flat]
* Make printtup a bit faster
@ 2024-08-29 09:40 Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
0 siblings, 1 reply; 24+ messages in thread
From: Andy Fan @ 2024-08-29 09:40 UTC (permalink / raw)
To: pgsql-hackers
Usually I see printtup in the perf-report with a noticeable ratio. Take
"SELECT * FROM pg_class" for example, we can see:
85.65% 3.25% postgres postgres [.] printtup
The high level design of printtup is:
1. Used a pre-allocated StringInfo DR_printtup.buf to store data for
each tuples.
2. for each datum in the tuple, it calls the type-specific out function
and get a cstring.
3. after get the cstring, we figure out the "len" and add both len and
'data' into DR_printtup.buf.
4. after all the datums are handled, socket_putmessage copies them into
PqSendBuffer.
5. When the usage of PgSendBuffer is up to PqSendBufferSize, using send
syscall to sent them into client (by copying the data from userspace to
kernel space again).
Part of the slowness is caused by "memcpy", "strlen" and palloc in
outfunction.
8.35% 8.35% postgres libc.so.6 [.] __strlen_avx2
4.27% 0.00% postgres libc.so.6 [.] __memcpy_avx_unaligned_erms
3.93% 3.93% postgres postgres [.] palloc (part of them caused by
out function)
5.70% 5.70% postgres postgres [.] AllocSetAlloc (part of them
caused by printtup.)
My high level proposal is define a type specific print function like:
oidprint(Datum datum, StringInfo buf)
textprint(Datum datum, StringInfo buf)
This function should append both data and len into buf directly.
for the oidprint case, we can avoid:
5. the dedicate palloc in oid function.
6. the memcpy from the above memory into DR_printtup.buf
for the textprint case, we can avoid
7. strlen, since we can figure out the length from varlena.vl_len
int2/4/8/timestamp/date/time are similar with oid. and numeric, varchar
are similar with text. This almost covers all the common used type.
Hard coding the relationship between common used type and {type}print
function OID looks not cool, Adding a new attribute in pg_type looks too
aggressive however. Anyway this is the next topic to talk about.
If a type's print function is not defined, we can still using the out
function (and PrinttupAttrInfo caches FmgrInfo rather than
FunctionCallInfo, so there is some optimization in this step as well).
This proposal covers the step 2 & 3. If we can do something more
aggressively, we can let the xxxprint print to PqSendBuffer directly,
but this is more complex and need some infrastructure changes. the
memcpy in step 4 is: "1.27% __memcpy_avx_unaligned_erms" in my above
case.
What do you think?
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2024-08-29 11:51 ` David Rowley <dgrowleyml@gmail.com>
2024-08-29 15:33 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 16:20 ` Re: Make printtup a bit faster Andreas Karlsson <andreas@proxel.se>
0 siblings, 3 replies; 24+ messages in thread
From: David Rowley @ 2024-08-29 11:51 UTC (permalink / raw)
To: Andy Fan <zhihuifan1213@163.com>; +Cc: pgsql-hackers
On Thu, 29 Aug 2024 at 21:40, Andy Fan <zhihuifan1213@163.com> wrote:
>
>
> Usually I see printtup in the perf-report with a noticeable ratio.
> Part of the slowness is caused by "memcpy", "strlen" and palloc in
> outfunction.
Yeah, it's a pretty inefficient API from a performance point of view.
> My high level proposal is define a type specific print function like:
>
> oidprint(Datum datum, StringInfo buf)
> textprint(Datum datum, StringInfo buf)
I think what we should do instead is make the output functions take a
StringInfo and just pass it the StringInfo where we'd like the bytes
written.
That of course would require rewriting all the output functions for
all the built-in types, so not a small task. Extensions make that job
harder. I don't think it would be good to force extensions to rewrite
their output functions, so perhaps some wrapper function could help us
align the APIs for extensions that have not been converted yet.
There's a similar problem with input functions not having knowledge of
the input length. You only have to look at textin() to see how useful
that could be. Fixing that would probably make COPY FROM horrendously
faster. Team that up with SIMD for the delimiter char search and COPY
go a bit better still. Neil Conway did propose the SIMD part in [1],
but it's just not nearly as good as it could be when having to still
perform the strlen() calls.
I had planned to work on this for PG18, but I'd be happy for some
assistance if you're willing.
David
[1] https://postgr.es/m/CAOW5sYb1HprQKrzjCsrCP1EauQzZy+njZ-AwBbOUMoGJHJS7Sw@mail.gmail.com
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2024-08-29 15:33 ` Tom Lane <tgl@sss.pgh.pa.us>
2024-08-30 00:31 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2 siblings, 1 reply; 24+ messages in thread
From: Tom Lane @ 2024-08-29 15:33 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: Andy Fan <zhihuifan1213@163.com>; pgsql-hackers
David Rowley <dgrowleyml@gmail.com> writes:
> [ redesign I/O function APIs ]
> I had planned to work on this for PG18, but I'd be happy for some
> assistance if you're willing.
I'm skeptical that such a thing will ever be practical. To avoid
breaking un-converted data types, all the call sites would have to
support both old and new APIs. To avoid breaking non-core callers,
all the I/O functions would have to support both old and new APIs.
That probably adds enough overhead to negate whatever benefit you'd
get.
regards, tom lane
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-29 15:33 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
@ 2024-08-30 00:31 ` David Rowley <dgrowleyml@gmail.com>
2024-08-30 05:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 1 reply; 24+ messages in thread
From: David Rowley @ 2024-08-30 00:31 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: Andy Fan <zhihuifan1213@163.com>; pgsql-hackers
On Fri, 30 Aug 2024 at 03:33, Tom Lane <tgl@sss.pgh.pa.us> wrote:
>
> David Rowley <dgrowleyml@gmail.com> writes:
> > [ redesign I/O function APIs ]
> > I had planned to work on this for PG18, but I'd be happy for some
> > assistance if you're willing.
>
> I'm skeptical that such a thing will ever be practical. To avoid
> breaking un-converted data types, all the call sites would have to
> support both old and new APIs. To avoid breaking non-core callers,
> all the I/O functions would have to support both old and new APIs.
> That probably adds enough overhead to negate whatever benefit you'd
> get.
Scepticism is certainly good when it comes to such a large API change.
I don't want to argue with you, but I'd like to state a few things
about why I think you're wrong on this...
So, we currently return cstrings in our output functions. Let's take
jsonb_out() as an example, to build that cstring, we make a *new*
StringInfoData on *every call* inside JsonbToCStringWorker(). That
gives you 1024 bytes before you need to enlarge it. However, it's
maybe not all bad as we have some size estimations there to call
enlargeStringInfo(), only that's a bit wasteful as it does a
repalloc() which memcpys the freshly allocated 1024 bytes allocated in
initStringInfo() when it doesn't yet contain any data. After
jsonb_out() has returned and we have the cstring, only we forgot the
length of the string, so most places will immediately call strlen() or
do that indirectly via appendStringInfoString(). For larger JSON
documents, that'll likely require pulling cachelines back into L1
again. I don't know how modern CPU cacheline eviction works, but if it
was as simple as FIFO then the strlen() would flush all those
cachelines only for memcpy() to have to read them back again for
output strings larger than L1.
If we rewrote all of core's output functions to use the new API, then
the branch to test the function signature would be perfectly
predictable and amount to an extra cmp and jne/je opcode. So, I just
don't agree with the overheads negating the benefits comment. You're
probably off by 1 order of magnitude at the minimum and for
medium/large varlena types likely 2-3+ orders. Even a simple int4out
requires a palloc()/memcpy. If we were outputting lots of data, e.g.
in a COPY operation, the output buffer would seldom need to be
enlarged as it would quickly adjust to the correct size.
For the input functions, the possible gains are extensive too.
textin() is a good example, it uses cstring_to_text(), but could be
changed to use cstring_to_text_with_len(). Knowing the input string
length also opens the door to SIMD. Take int4in() as an example, if
pg_strtoint32_safe() knew its input length there are a bunch of
prechecks that could be done with either 64-bit SWAR or with SIMD.
For example, if you knew you had an 8-char string of decimal digits
then converting that to an int32 is quite cheap. It's impossible to
overflow an int32 with 8 decimal digits, so no overflow checks need to
be done until there are at least 10 decimal digits. ca6fde922 seems
like good enough example of the possible gains of SIMD vs
byte-at-a-time processing. I saw some queries go 4x faster there and
that was me trying to keep the JSON document sizes realistic.
byte-at-a-time is just not enough to saturate RAM speed. Take DDR5,
for example, Wikipedia says it has a bandwidth of 32–64 GB/s, so
unless we discover room temperature superconductors, we're not going
to see any massive jump in clock speeds any time soon, and with 5 or
6Ghz CPUs, there's just no way to get anywhere near that bandwidth by
processing byte-at-a-time. For some sort of nieve strcpy() type
function, you're going to need at least a cmp and mov, even if those
were latency=1 (which they're not, see [1]), you can only do 2.5
billion of those two per second on a 5Ghz processor. I've done tested,
but hypothetically (assuming latency=1) that amounts to processing
2.5GB/s, i.e. a long way from DDR5 RAM speed and that's not taking
into account having to increment pointers to the next byte on each
loop.
David
[1] https://www.agner.org/optimize/instruction_tables.pdf
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-29 15:33 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2024-08-30 00:31 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2024-08-30 05:00 ` Andy Fan <zhihuifan1213@163.com>
2024-09-02 03:18 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 1 reply; 24+ messages in thread
From: Andy Fan @ 2024-08-30 05:00 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; pgsql-hackers
David Rowley <dgrowleyml@gmail.com> writes:
> On Fri, 30 Aug 2024 at 03:33, Tom Lane <tgl@sss.pgh.pa.us> wrote:
>>
>> David Rowley <dgrowleyml@gmail.com> writes:
>> > [ redesign I/O function APIs ]
>> > I had planned to work on this for PG18, but I'd be happy for some
>> > assistance if you're willing.
>>
>> I'm skeptical that such a thing will ever be practical. To avoid
>> breaking un-converted data types, all the call sites would have to
>> support both old and new APIs. To avoid breaking non-core callers,
>> all the I/O functions would have to support both old and new APIs.
>> That probably adds enough overhead to negate whatever benefit you'd
>> get.
>
> So, we currently return cstrings in our output functions. Let's take
> jsonb_out() as an example, to build that cstring, we make a *new*
> StringInfoData on *every call* inside JsonbToCStringWorker(). That
> gives you 1024 bytes before you need to enlarge it. However, it's
> maybe not all bad as we have some size estimations there to call
> enlargeStringInfo(), only that's a bit wasteful as it does a
> repalloc() which memcpys the freshly allocated 1024 bytes allocated in
> initStringInfo() when it doesn't yet contain any data. After
> jsonb_out() has returned and we have the cstring, only we forgot the
> length of the string, so most places will immediately call strlen() or
> do that indirectly via appendStringInfoString(). For larger JSON
> documents, that'll likely require pulling cachelines back into L1
> again. I don't know how modern CPU cacheline eviction works, but if it
> was as simple as FIFO then the strlen() would flush all those
> cachelines only for memcpy() to have to read them back again for
> output strings larger than L1.
The attached is PoC of this idea, not matter which method are adopted
(rewrite all the outfunction or a optional print function), I think the
benefit will be similar. In the blew test case, it shows us 10%+
improvements. (0.134ms vs 0.110ms)
create table demo as select oid as oid1, relname::text as text1, relam,
relname::text as text2 from pg_class;
pgbench:
select * from demo;
--
Best Regards
Andy Fan
Attachments:
[text/x-diff] v20240830-0001-Avoiding-some-memcpy-strlen-palloc-in-prin.patch (5.6K, ../../87v7zihaf1.fsf@163.com/2-v20240830-0001-Avoiding-some-memcpy-strlen-palloc-in-prin.patch)
download | inline diff:
From 5ace763a5126478da1c3cb68d5221d83e45d2f34 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Fri, 30 Aug 2024 12:50:54 +0800
Subject: [PATCH v20240830 1/1] Avoiding some memcpy, strlen, palloc in
printtup.
https://www.postgresql.org/message-id/87wmjzfz0h.fsf%40163.com
---
src/backend/access/common/printtup.c | 40 ++++++++++++++++++++++------
src/backend/utils/adt/oid.c | 20 ++++++++++++++
src/backend/utils/adt/varlena.c | 17 ++++++++++++
src/include/catalog/pg_proc.dat | 9 ++++++-
4 files changed, 77 insertions(+), 9 deletions(-)
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index c78cc39308..ecba4a7113 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
@@ -274,10 +276,25 @@ 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);
+ /*
+ * If the type defines a print function, then use it
+ * rather than outfunction.
+ *
+ * XXX: need a generic function to improve the if-elseif.
+ */
+ if (attr->atttypid == OIDOID)
+ fmgr_info(F_OIDPRINT, &thisState->p_finfo);
+ else if (attr->atttypid == TEXTOID)
+ fmgr_info(F_TEXTPRINT, &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 +372,17 @@ 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)
+ {
+ 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/oid.c b/src/backend/utils/adt/oid.c
index 56fb1fd77c..cc85d920c8 100644
--- a/src/backend/utils/adt/oid.c
+++ b/src/backend/utils/adt/oid.c
@@ -53,6 +53,26 @@ 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 *lenp;
+ uint32 data_len;
+
+ /* 12 is the max length for an oid's text presentation. */
+ enlargeStringInfo(buf, sizeof(int32) + 12);
+
+ /* note the position for len */
+ lenp = (uint32 *) (buf->data + buf->len);
+ data_len = pg_snprintf(buf->data + buf->len + sizeof(int), 12, "%u", o);
+ *lenp = pg_hton32(data_len);
+ buf->len += sizeof(uint32) + data_len;
+
+ PG_RETURN_VOID();
+}
+
/*
* oidrecv - converts external binary format to oid
*/
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index 7c6391a276..3b7006d54a 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -594,6 +594,23 @@ 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;
+ uint32 ni = pg_hton32(text_len);
+
+ enlargeStringInfo(buf, sizeof(int32) + text_len);
+ memcpy((char *pg_restrict) buf->data + buf->len, &ni, sizeof(uint32));
+ memcpy(buf->data + buf->len + sizeof(int), VARDATA(txt), text_len);
+ buf->len += sizeof(uint32) + 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..74eeead4de 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -100,6 +100,10 @@
{ oid => '47', descr => 'I/O',
proname => 'textout', prorettype => 'cstring', proargtypes => 'text',
prosrc => 'textout' },
+{
+ oid => '8907', descr => 'I/O',
+ proname => 'textprint', prorettype => 'void', proargtypes => 'text internal',
+ prosrc => 'textprint' },
{ oid => '48', descr => 'I/O',
proname => 'tidin', prorettype => 'tid', proargtypes => 'cstring',
prosrc => 'tidin' },
@@ -4718,7 +4722,10 @@
{ oid => '1799', descr => 'I/O',
proname => 'oidout', prorettype => 'cstring', proargtypes => 'oid',
prosrc => 'oidout' },
-
+{
+ oid => '9771', descr => 'I/O',
+ proname => 'oidprint', prorettype => 'void', proargtypes => 'oid internal',
+ prosrc => 'oidprint'},
{ oid => '3058', descr => 'concatenate values',
proname => 'concat', provariadic => 'any', proisstrict => 'f',
provolatile => 's', prorettype => 'text', proargtypes => 'any',
--
2.45.1
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-29 15:33 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2024-08-30 00:31 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 05:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2024-09-02 03:18 ` Andy Fan <zhihuifan1213@163.com>
0 siblings, 0 replies; 24+ messages in thread
From: Andy Fan @ 2024-09-02 03:18 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; pgsql-hackers
Andy Fan <zhihuifan1213@163.com> writes:
> The attached is PoC of this idea, not matter which method are adopted
> (rewrite all the outfunction or a optional print function), I think the
> benefit will be similar. In the blew test case, it shows us 10%+
> improvements. (0.134ms vs 0.110ms)
After working on more {type}_print functions, I'm thinking it is pretty
like the 3rd IO function which shows some confused maintainence
effort. so I agree refactoring the existing out function is a better
idea. I'd like to work on _print function body first for easy review and
testing. after all, if some common issues exists in these changes,
it is better to know that before we working on the 700+ out functions.
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2024-08-30 00:09 ` Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2 siblings, 1 reply; 24+ messages in thread
From: Andy Fan @ 2024-08-30 00:09 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
David Rowley <dgrowleyml@gmail.com> writes:
Hello David,
>> My high level proposal is define a type specific print function like:
>>
>> oidprint(Datum datum, StringInfo buf)
>> textprint(Datum datum, StringInfo buf)
>
> I think what we should do instead is make the output functions take a
> StringInfo and just pass it the StringInfo where we'd like the bytes
> written.
>
> That of course would require rewriting all the output functions for
> all the built-in types, so not a small task. Extensions make that job
> harder. I don't think it would be good to force extensions to rewrite
> their output functions, so perhaps some wrapper function could help us
> align the APIs for extensions that have not been converted yet.
I have the similar concern as Tom that this method looks too
aggressive. That's why I said:
"If a type's print function is not defined, we can still using the out
function."
AND
"Hard coding the relationship between [common] used type and {type}print
function OID looks not cool, Adding a new attribute in pg_type looks too
aggressive however. Anyway this is the next topic to talk about."
What would be the extra benefit we redesign all the out functions?
> There's a similar problem with input functions not having knowledge of
> the input length. You only have to look at textin() to see how useful
> that could be. Fixing that would probably make COPY FROM horrendously
> faster. Team that up with SIMD for the delimiter char search and COPY
> go a bit better still. Neil Conway did propose the SIMD part in [1],
> but it's just not nearly as good as it could be when having to still
> perform the strlen() calls.
OK, I think I can understand the needs to make in-function knows the
input length and good to know the SIMD part for delimiter char
search. strlen looks like a delimiter char search ('\0') as well. Not
sure if "strlen" has been implemented with SIMD part, but if not, why?
> I had planned to work on this for PG18, but I'd be happy for some
> assistance if you're willing.
I see you did many amazing work with cache-line-frindly data struct
design, branch predition optimization and SIMD optimization. I'd like to
try one myself. I'm not sure if I can meet the target, what if we handle
the out/in function separately (can be by different people)?
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2024-08-30 00:38 ` David Rowley <dgrowleyml@gmail.com>
2024-08-30 01:04 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 2 replies; 24+ messages in thread
From: David Rowley @ 2024-08-30 00:38 UTC (permalink / raw)
To: Andy Fan <zhihuifan1213@163.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
On Fri, 30 Aug 2024 at 12:10, Andy Fan <zhihuifan1213@163.com> wrote:
> What would be the extra benefit we redesign all the out functions?
If I've understood your proposal correctly, it sounds like you want to
invent a new "print" output function for each type to output the Datum
onto a StringInfo, if that's the case, what would be the point of
having both versions? If there's anywhere we call output functions
where the resulting value isn't directly appended to a StringInfo,
then we could just use a temporary StringInfo to obtain the cstring
and its length.
David
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2024-08-30 01:04 ` Andy Fan <zhihuifan1213@163.com>
2024-08-30 01:13 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
1 sibling, 1 reply; 24+ messages in thread
From: Andy Fan @ 2024-08-30 01:04 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
David Rowley <dgrowleyml@gmail.com> writes:
> On Fri, 30 Aug 2024 at 12:10, Andy Fan <zhihuifan1213@163.com> wrote:
>> What would be the extra benefit we redesign all the out functions?
>
> If I've understood your proposal correctly, it sounds like you want to
> invent a new "print" output function for each type to output the Datum
> onto a StringInfo,
Mostly yes, but not for [each type at once], just for the [common used
type], like int2/4/8, float4/8, date/time/timestamp, text/.. and so on.
> if that's the case, what would be the point of having both versions?
The biggest benefit would be compatibility.
In my opinion, print function (not need to be in pg_type at all) is as
an optimization and optional, in some performance critical path we can
replace the out-function with printfunction, like (printtup). if such
performance-critical path find a type without a print-function is
defined, just keep the old way.
Kind of like supportfunction for proc, this is for data type? Within
this way, changes would be much smaller and step-by-step.
> If there's anywhere we call output functions
> where the resulting value isn't directly appended to a StringInfo,
> then we could just use a temporary StringInfo to obtain the cstring
> and its length.
I think this is true, but it requests some caller's code change.
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 01:04 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2024-08-30 01:13 ` David Rowley <dgrowleyml@gmail.com>
2024-08-30 01:34 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 1 reply; 24+ messages in thread
From: David Rowley @ 2024-08-30 01:13 UTC (permalink / raw)
To: Andy Fan <zhihuifan1213@163.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
On Fri, 30 Aug 2024 at 13:04, Andy Fan <zhihuifan1213@163.com> wrote:
>
> David Rowley <dgrowleyml@gmail.com> writes:
> > If there's anywhere we call output functions
> > where the resulting value isn't directly appended to a StringInfo,
> > then we could just use a temporary StringInfo to obtain the cstring
> > and its length.
>
> I think this is true, but it requests some caller's code change.
Yeah, calling code would need to be changed to take advantage of the
new API, however, the differences in which types support which API
could be hidden inside OutputFunctionCall(). That function could just
fake up a StringInfo for any types that only support the old cstring
API. That means we don't need to add handling for both cases
everywhere we need to call the output function. It's possible that
could make some operations slightly slower when only the old API is
available, but then maybe not as we do now have read-only StringInfos.
Maybe the StringInfoData.data field could just be set to point to the
given cstring using initReadOnlyStringInfo() rather than doing
appendBinaryStringInfo() onto yet another buffer for the old API.
David
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 01:04 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 01:13 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2024-08-30 01:34 ` Andy Fan <zhihuifan1213@163.com>
0 siblings, 0 replies; 24+ messages in thread
From: Andy Fan @ 2024-08-30 01:34 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
David Rowley <dgrowleyml@gmail.com> writes:
> On Fri, 30 Aug 2024 at 13:04, Andy Fan <zhihuifan1213@163.com> wrote:
>>
>> David Rowley <dgrowleyml@gmail.com> writes:
>> > If there's anywhere we call output functions
>> > where the resulting value isn't directly appended to a StringInfo,
>> > then we could just use a temporary StringInfo to obtain the cstring
>> > and its length.
>>
>> I think this is true, but it requests some caller's code change.
>
> Yeah, calling code would need to be changed to take advantage of the
> new API, however, the differences in which types support which API
> could be hidden inside OutputFunctionCall(). That function could just
> fake up a StringInfo for any types that only support the old cstring
> API. That means we don't need to add handling for both cases
> everywhere we need to call the output function.
We can do this, then the printtup case (stands for some performance
crital path) still need to change discard OutputFunctionCall() since it
uses the fake StringInfo then a memcpy is needed again IIUC.
Besides above, my major concerns about your proposal need to change [all
the type's outfunction at once] which is too aggresive for me. In the
fresh setup without any extension is created, "SELECT count(*) FROM
pg_type" returns 627 already, So other piece of my previous reply is
more important to me.
It is great that both of us feeling the current stategy is not good for
performance:)
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2026-05-03 14:41 ` Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
1 sibling, 1 reply; 24+ messages in thread
From: Andy Fan @ 2026-05-03 14:41 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
Hi David,
> On Fri, 30 Aug 2024 at 12:10, Andy Fan <zhihuifan1213@163.com> wrote:
>> What would be the extra benefit we redesign all the out functions?
>
> If I've understood your proposal correctly, it sounds like you want to
> invent a new "print" output function for each type to output the Datum
> onto a StringInfo, if that's the case, what would be the point of
> having both versions?
You understood me correctly and I thought we should maintain one version
two years ago, so I tried to implement this idea today. The first issue I
want to talk about now how to define the function protocol in SQL, take
int4out for example:
master: cstring int4out(integer);
New protocol: void int4out(integer, internal). and the internal is
StringInfo acutally.
The direct impaction would be:
master support:
postgres=# select int4out(8);
int4out
---------
8
(1 row)
After our change, user could not invoke any {type}out function anymore
in SQL since it takes 'internal' as an agrument. I am not sure if people
would write SQL like this, but it'd be good to have a talk about this.
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2026-05-04 04:38 ` Tom Lane <tgl@sss.pgh.pa.us>
2026-05-04 08:26 ` Re: Make printtup a bit faster Andres Freund <andres@anarazel.de>
2026-05-06 13:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 2 replies; 24+ messages in thread
From: Tom Lane @ 2026-05-04 04:38 UTC (permalink / raw)
To: Andy Fan <zhihuifan1213@163.com>; +Cc: David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Andy Fan <zhihuifan1213@163.com> writes:
> You understood me correctly and I thought we should maintain one version
> two years ago, so I tried to implement this idea today. The first issue I
> want to talk about now how to define the function protocol in SQL, take
> int4out for example:
> master: cstring int4out(integer);
> New protocol: void int4out(integer, internal). and the internal is
> StringInfo acutally.
> The direct impaction would be:
> master support:
> postgres=# select int4out(8);
> int4out
> ---------
> 8
> (1 row)
> After our change, user could not invoke any {type}out function anymore
> in SQL since it takes 'internal' as an agrument. I am not sure if people
> would write SQL like this, but it'd be good to have a talk about this.
I think you missed the point of what I said two years ago: you will
never be able to remove the existing output function API, nor the
per-datatype functions that implement that API. Even if we were
willing to convert every last one of the in-core callers and callees,
doing that would break too much non-core code. So the above example
is never going to stop working.
We can consider implementing a new datatype output API alongside the
existing one. But it'd likely not be callable from SQL, so the
question of SQL compatibility is moot.
My own guess is that even if we built a new API, only a fairly small
number of datatypes would find it worth the trouble to support.
The potential win seems clear for, say, textout: there's really no
computation to do, only data copying, so halving the amount of
copying is attractive. But I bet you won't measure much percentage
improvement for numeric_out or point_out.
This line of thought suggests that maybe some special-purpose hack
would be a better answer than defining a new datatype API. It's hard
to tell without some concrete performance numbers, which are sadly
lacking in this thread.
regards, tom lane
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
@ 2026-05-04 08:26 ` Andres Freund <andres@anarazel.de>
2026-05-04 13:09 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
1 sibling, 1 reply; 24+ messages in thread
From: Andres Freund @ 2026-05-04 08:26 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: Andy Fan <zhihuifan1213@163.com>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Hi,
On 2026-05-04 00:38:38 -0400, Tom Lane wrote:
> My own guess is that even if we built a new API, only a fairly small
> number of datatypes would find it worth the trouble to support.
> The potential win seems clear for, say, textout: there's really no
> computation to do, only data copying, so halving the amount of
> copying is attractive. But I bet you won't measure much percentage
> improvement for numeric_out or point_out.
>
> This line of thought suggests that maybe some special-purpose hack
> would be a better answer than defining a new datatype API. It's hard
> to tell without some concrete performance numbers, which are sadly
> lacking in this thread.
FWIW, I've experimented fixing this overhead before, and what I did was to
pass an optional context via the fcinfo, and output / send functions could use
memory allocated via that optional context object, rather than doing it
allocating in CurrentMemoryContext. For the send functions that looks
reasonably clean, given that it already deals with a stringinfo. For out
functions it's a bit uglier, but still somewhat acceptable.
For e.g. bytea, integers, etc this is relatively easy. Where it gets harder
is stuff like textsend(), where the encoding conversion infrastructure
basically preallocates.
It might make sense to start work on this by having a version of
pg_server_to_client() that doesn't pessimistically copy the data, but instead
have it build the converted output directly in the StringInfo. Because that
would be an independent benefit (for printtup()->pg_sendcountedtext()) and a
required building block for the better output functions.
Greetings,
Andres Freund
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2026-05-04 08:26 ` Re: Make printtup a bit faster Andres Freund <andres@anarazel.de>
@ 2026-05-04 13:09 ` Tom Lane <tgl@sss.pgh.pa.us>
0 siblings, 0 replies; 24+ messages in thread
From: Tom Lane @ 2026-05-04 13:09 UTC (permalink / raw)
To: Andres Freund <andres@anarazel.de>; +Cc: Andy Fan <zhihuifan1213@163.com>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Andres Freund <andres@anarazel.de> writes:
> FWIW, I've experimented fixing this overhead before, and what I did was to
> pass an optional context via the fcinfo, and output / send functions could use
> memory allocated via that optional context object, rather than doing it
> allocating in CurrentMemoryContext. For the send functions that looks
> reasonably clean, given that it already deals with a stringinfo. For out
> functions it's a bit uglier, but still somewhat acceptable.
Hmm, yeah, that could be a route to building a new optional API
without causing compatibility problems everywhere.
regards, tom lane
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
@ 2026-05-06 13:00 ` Andy Fan <zhihuifan1213@163.com>
2026-05-06 15:52 ` Re: Make printtup a bit faster Andres Freund <andres@anarazel.de>
1 sibling, 1 reply; 24+ messages in thread
From: Andy Fan @ 2026-05-06 13:00 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: David Rowley <dgrowleyml@gmail.com>; pgsql-hackers; Andres Freund <andres@anarazel.de>
Hi,
> Andy Fan <zhihuifan1213@163.com> writes:
>> You understood me correctly and I thought we should maintain one version
>> two years ago, so I tried to implement this idea today. The first issue I
>> want to talk about now how to define the function protocol in SQL, take
>> int4out for example:
>
>> master: cstring int4out(integer);
>> New protocol: void int4out(integer, internal). and the internal is
>> StringInfo acutally.
>
>> The direct impaction would be:
>
>> master support:
>> postgres=# select int4out(8);
>> int4out
>> ---------
>> 8
>> (1 row)
>
>> After our change, user could not invoke any {type}out function anymore
>> in SQL since it takes 'internal' as an agrument. I am not sure if people
>> would write SQL like this, but it'd be good to have a talk about this.
>
> I think you missed the point of what I said two years ago: you will
> never be able to remove the existing output function API, nor the
> per-datatype functions that implement that API. Even if we were
> willing to convert every last one of the in-core callers and callees,
> doing that would break too much non-core code. So the above example
> is never going to stop working.
OK, I thought David supported this and you didn't object it, so I
planned to try with this way.
> We can consider implementing a new datatype output API alongside the
> existing one. But it'd likely not be callable from SQL, so the
> question of SQL compatibility is moot.
>
> My own guess is that even if we built a new API, only a fairly small
> number of datatypes would find it worth the trouble to support.
> The potential win seems clear for, say, textout: there's really no
> computation to do, only data copying, so halving the amount of
> copying is attractive. But I bet you won't measure much percentage
> improvement for numeric_out or point_out.
Is this similar with the soluation I called as print function at [1]
"""
My high level proposal is define a type specific print function like:
oidprint(Datum datum, StringInfo buf)
textprint(Datum datum, StringInfo buf)
"""
Then we can have benefits like compatibility, incremental development
(start from common used/potential win data type). But as David said
"what would be the point of having both versions?" at [2], actually I
was persuaded by this, I thought David's method paies more effort to
current patch now and save the maintain effort in future. (To be honest,
I am not good at the trade off...)
So looks we have 3 soluation for now IIUC.
(1) Maintaining one copy of output function (David's proposal).
(2) Add a new type of API for some specific data types like above.
(3) Andres's method, acutally I can't follow well now.
From Andres:
> FWIW, I've experimented fixing this overhead before, and what I did was to
> pass an optional context via the fcinfo, and output / send functions could use
> memory allocated via that optional context object, rather than doing it
> allocating in CurrentMemoryContext. For the send functions that looks
> reasonably clean, given that it already deals with a stringinfo. For out
> functions it's a bit uglier, but still somewhat acceptable.
Puting optional context via the fcinfo looks novel to me (I have zero
experience to use fcinfo utility.). Then I'm not sure how to use the
optional context, Will it be a MemoryContext or a StringInfo? If
MemoryContext, then how to avoid the memory copy in the printtup
sistuation or this method has different target.
> This line of thought suggests that maybe some special-purpose hack
> would be a better answer than defining a new datatype API. It's hard
> to tell without some concrete performance numbers, which are sadly
> lacking in this thread.
Does the data in [3] helpful? Quote the message there:
"The attached is PoC of this idea, not matter which method are adopted
(rewrite all the outfunction or a optional print function), I think the
benefit will be similar. In the blew test case, it shows us 10%+
improvements. (0.134ms vs 0.110ms)
create table demo as select oid as oid1, relname::text as text1, relam,
relname::text as text2 from pg_class;
pgbench:
select * from demo;"
I re-attached the patch there, just rebased with the latest master.
[1] https://www.postgresql.org/message-id/87wmjzfz0h.fsf%40163.com
[2]
https://www.postgresql.org/message-id/CAApHDvqHthJb6baDhgTE5T4RLW6nEX%3Dr239EYmpjfg%3DWq5CqQA%40mail...
[3] https://www.postgresql.org/message-id/87v7zihaf1.fsf%40163.com
--
Best Regards
Andy Fan
Attachments:
[text/x-diff] v20260912-0003-add-unlikely-hint-for-enlargeStringInfo.patch (1.3K, ../../877bpghevm.fsf@163.com/2-v20260912-0003-add-unlikely-hint-for-enlargeStringInfo.patch)
download | inline diff:
From f4b88d3533008c2d7a23f6b907d4d1adac6dad02 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Wed, 11 Sep 2024 12:25:52 +0800
Subject: [PATCH v20260912 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 ae39540e468..a725ef132d7 100644
--- a/src/common/stringinfo.c
+++ b/src/common/stringinfo.c
@@ -345,7 +345,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);
@@ -354,7 +354,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.43.0
[text/x-diff] v20260912-0001-Refactor-float8out_internval-for-better-pe.patch (6.3K, ../../877bpghevm.fsf@163.com/3-v20260912-0001-Refactor-float8out_internval-for-better-pe.patch)
download | inline diff:
From 7e125bab012fa05cfc8637ab13a3c84bb2939daa Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Wed, 11 Sep 2024 12:19:57 +0800
Subject: [PATCH v20260912 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 77263ab277f..a143690092b 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"
@@ -299,26 +300,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 362c29ab803..13ceade129e 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -571,22 +571,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 cc5ce013d0f..212faf08a50 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"
@@ -203,10 +204,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
@@ -255,12 +258,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
@@ -1041,9 +1052,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 74183ec5a2e..b3858188131 100644
--- a/src/include/catalog/pg_type.h
+++ b/src/include/catalog/pg_type.h
@@ -348,6 +348,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 ffa743d6273..69661a7071f 100644
--- a/src/include/utils/float.h
+++ b/src/include/utils/float.h
@@ -43,7 +43,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.43.0
[text/x-diff] v20260912-0002-Continue-to-remove-some-unnecesary-strlen-.patch (2.2K, ../../877bpghevm.fsf@163.com/4-v20260912-0002-Continue-to-remove-some-unnecesary-strlen-.patch)
download | inline diff:
From 8418f76079ddb589f9861a83059271b5eaceaf77 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Wed, 11 Sep 2024 12:21:39 +0800
Subject: [PATCH v20260912 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 | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,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
@@ -4774,11 +4775,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%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
[text/x-diff] v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch (30.0K, ../../877bpghevm.fsf@163.com/5-v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch)
download | inline diff:
From 03d9c947c960a8ac2a41ff35aebc3a1673446e13 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Thu, 12 Sep 2024 10:03:57 +0000
Subject: [PATCH v20260912 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 616bdafd395..860e67cfcc9 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"
@@ -50,6 +51,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
@@ -244,6 +246,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
*/
@@ -275,10 +318,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)
{
@@ -356,10 +407,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 698863924ee..6d1d9403c2d 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 c3327440380..4d606e7888f 100644
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -196,6 +196,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
*/
@@ -291,13 +316,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");
}
@@ -1603,6 +1636,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
*/
@@ -2417,6 +2469,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 83c3c85305b..85da5780870 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4346,9 +4346,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)
@@ -4420,6 +4421,7 @@ EncodeDateOnly(struct pg_tm *tm, int style, char *str)
str += 3;
}
*str = '\0';
+ return str - start;
}
@@ -4430,10 +4432,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);
@@ -4442,6 +4447,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;
}
@@ -4460,11 +4466,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);
@@ -4624,6 +4633,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 13ceade129e..76ad00c60d9 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -373,6 +373,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
*/
@@ -563,10 +589,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 4c894a49d5d..5a121a46b94 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
*/
@@ -333,6 +349,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 19bb30f2d0f..8580c273792 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 cb23dfe9b95..84719a79ae8 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -509,7 +509,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);
@@ -820,11 +820,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() -
*
@@ -1027,7 +1068,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)
@@ -7251,7 +7292,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;
@@ -7279,7 +7320,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;
/*
@@ -7378,6 +7426,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;
}
@@ -7451,7 +7505,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, true);
- sig_out = get_str_from_var(&tmp_var);
+ sig_out = get_str_from_var(&tmp_var, NULL);
free_var(&tmp_var);
@@ -8004,7 +8058,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 a3419728971..96df114eaf6 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 288d696be77..27b546deb74 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -87,7 +87,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 */
@@ -244,6 +244,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
*/
@@ -789,6 +816,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
*/
@@ -983,6 +1040,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
*/
@@ -1577,26 +1663,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 a62e55eec19..e14c66999a8 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 c0ff51bd2fc..3fa6bff1182 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -293,6 +293,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 fa9ae79082b..938f5e2d585 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -4877,7 +4877,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',
@@ -12769,4 +12768,86 @@
proname => 'hashoid8extended', prorettype => 'int8',
proargtypes => 'oid8 int8', prosrc => 'hashoid8extended' },
+{
+ 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 079652c8ce4..6318fe8be5b 100644
--- a/src/include/lib/stringinfo.h
+++ b/src/include/lib/stringinfo.h
@@ -267,4 +267,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 6063810891e..3a2fe34061e 100644
--- a/src/include/utils/date.h
+++ b/src/include/utils/date.h
@@ -111,7 +111,7 @@ extern DateADT timestamptz2date_safe(TimestampTz timestamp, Node *escontext);
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 f77c6acd8b6..a6754195e0b 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.43.0
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2026-05-06 13:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2026-05-06 15:52 ` Andres Freund <andres@anarazel.de>
2026-05-06 16:07 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2026-05-07 12:40 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 2 replies; 24+ messages in thread
From: Andres Freund @ 2026-05-06 15:52 UTC (permalink / raw)
To: Andy Fan <zhihuifan1213@163.com>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Hi,
> From Andres:
>
> > FWIW, I've experimented fixing this overhead before, and what I did was to
> > pass an optional context via the fcinfo, and output / send functions could use
> > memory allocated via that optional context object, rather than doing it
> > allocating in CurrentMemoryContext. For the send functions that looks
> > reasonably clean, given that it already deals with a stringinfo. For out
> > functions it's a bit uglier, but still somewhat acceptable.
>
> Puting optional context via the fcinfo looks novel to me (I have zero
> experience to use fcinfo utility.).
We do that in a bunch of places, e.g. for the context of window functions
(c.f. PG_WINDOW_OBJECT() WindowObjectIsValid()).
> Then I'm not sure how to use the optional context, Will it be a
> MemoryContext or a StringInfo? If MemoryContext, then how to avoid the
> memory copy in the printtup sistuation or this method has different target.
I think it'd have to be something that includes the stringinfo.
Here's a very rough prototype for how it could look like. This clearly needs
more helpers that I introduced, but I thought this should be enough to show
the idea.
The first patch is a sketch of something that the second patch depends on, but
that I think we should probably do independently. I'm running working on a
laptop with an almost empty battery, but I'd expect it to be a bit faster than
what we do today.
Greetings,
Andres Freund
Attachments:
[text/x-diff] va1-0001-WIP-Use-permanent-FunctionCallInfo-in-printtup.patch (2.4K, ../../7nfy6enxgwzptesyd2oexlwtqaxtlhbec4yqs44mqgjbyanpss@icwtswsr3wam/2-va1-0001-WIP-Use-permanent-FunctionCallInfo-in-printtup.patch)
download | inline diff:
From a3af2227b88eef02db434f2ac66777d4b683a29e Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Wed, 6 May 2026 11:41:36 -0400
Subject: [PATCH va1 1/2] WIP: Use permanent FunctionCallInfo in printtup
Should probably be done similarly for COPY
---
src/backend/access/common/printtup.c | 15 +++++++++++++--
1 file changed, 13 insertions(+), 2 deletions(-)
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 616bdafd395..6fa93a6798a 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -50,6 +50,8 @@ 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 */
+ /* XXX: Would probably be faster to allocate "inline" */
+ FunctionCallInfo outstate; /* Prepared FCI for slightly faster calls */
} PrinttupAttrInfo;
typedef struct
@@ -291,6 +293,10 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unsupported format code: %d", format)));
+
+ /* both out and send funcs have one argument */
+ thisState->outstate = palloc0(SizeForFunctionCallInfo(1));
+ thisState->outstate->flinfo = &thisState->finfo;
}
}
@@ -353,12 +359,16 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
VALGRIND_CHECK_MEM_IS_DEFINED(DatumGetPointer(attr),
VARSIZE_ANY(DatumGetPointer(attr)));
+ /* fill in argument for output / send function */
+ thisState->outstate->args[0].value = attr;
+
if (thisState->format == 0)
{
/* Text output */
char *outputstr;
- outputstr = OutputFunctionCall(&thisState->finfo, attr);
+ outputstr = DatumGetCString(FunctionCallInvoke(thisState->outstate));
+ Assert(!thisState->outstate->isnull);
pq_sendcountedtext(buf, outputstr, strlen(outputstr));
}
else
@@ -366,7 +376,8 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
/* Binary output */
bytea *outputbytes;
- outputbytes = SendFunctionCall(&thisState->finfo, attr);
+ outputbytes = DatumGetByteaP(FunctionCallInvoke(thisState->outstate));
+ Assert(!thisState->outstate->isnull);
pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
pq_sendbytes(buf, VARDATA(outputbytes),
VARSIZE(outputbytes) - VARHDRSZ);
--
2.46.0.519.g2e7b89e038
[text/x-diff] va1-0002-Mega-WIP-Optimized-out-send-path-for-printtup.patch (7.5K, ../../7nfy6enxgwzptesyd2oexlwtqaxtlhbec4yqs44mqgjbyanpss@icwtswsr3wam/3-va1-0002-Mega-WIP-Optimized-out-send-path-for-printtup.patch)
download | inline diff:
From 2bdcbc8bf3b73694fd0bbfbc1907a3197b1129f9 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Wed, 6 May 2026 11:44:26 -0400
Subject: [PATCH va1 2/2] Mega-WIP: Optimized out/send path for printtup
Discussion: https://postgr.es/m/877bpghevm.fsf@163.com
---
src/include/nodes/miscnodes.h | 12 +++++
src/backend/access/common/printtup.c | 35 +++++++++++--
src/backend/utils/adt/int.c | 73 +++++++++++++++++++++++++---
src/backend/utils/adt/varlena.c | 40 ++++++++++++++-
4 files changed, 148 insertions(+), 12 deletions(-)
diff --git a/src/include/nodes/miscnodes.h b/src/include/nodes/miscnodes.h
index ec833001ab0..b3c189a5c0c 100644
--- a/src/include/nodes/miscnodes.h
+++ b/src/include/nodes/miscnodes.h
@@ -54,4 +54,16 @@ typedef struct ErrorSaveContext
((escontext) != NULL && IsA(escontext, ErrorSaveContext) && \
((ErrorSaveContext *) (escontext))->error_occurred)
+
+/*
+ * Type optionally passed to input/receive/output/send functions that allows
+ * those functions to opt into more efficient ways of performing their work
+ * (mainly reducing allocations & copies).
+ */
+typedef struct InOutContext
+{
+ NodeTag type;
+ StringInfo buf;
+} InOutContext;
+
#endif /* MISCNODES_H */
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 6fa93a6798a..2e3eb8f56d3 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -63,6 +63,7 @@ typedef struct
int nattrs;
PrinttupAttrInfo *myinfo; /* Cached info about each attr */
StringInfoData buf; /* output buffer (*not* in tmpcontext) */
+ InOutContext inout; /* FunctionCallInfo->context data */
MemoryContext tmpcontext; /* Memory context for per-row workspace */
} DR_printtup;
@@ -142,6 +143,9 @@ printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
FetchPortalTargetList(portal),
portal->formats);
+ myState->inout.type = T_InOutContext;
+ myState->inout.buf = &myState->buf;
+
/* ----------------
* We could set up the derived attr info at this time, but we postpone it
* until the first call of printtup, for 2 reasons:
@@ -297,6 +301,15 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
/* both out and send funcs have one argument */
thisState->outstate = palloc0(SizeForFunctionCallInfo(1));
thisState->outstate->flinfo = &thisState->finfo;
+
+ /*
+ * The idea here is that output functions can optionally use more
+ * efficient paths if they see that the context is InOutContext, by
+ * directly appending correctly formatted output into the output
+ * buffer.
+ */
+ thisState->outstate->context = (Node *) &myState->inout;
+ thisState->outstate->nargs = 1;
}
}
@@ -369,7 +382,13 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
outputstr = DatumGetCString(FunctionCallInvoke(thisState->outstate));
Assert(!thisState->outstate->isnull);
- pq_sendcountedtext(buf, outputstr, strlen(outputstr));
+
+ /*
+ * If outputstr == NULL, the output function directly appended a
+ * correctly formatted message.
+ */
+ if (outputstr)
+ pq_sendcountedtext(buf, outputstr, strlen(outputstr));
}
else
{
@@ -378,9 +397,17 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
outputbytes = DatumGetByteaP(FunctionCallInvoke(thisState->outstate));
Assert(!thisState->outstate->isnull);
- pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
- pq_sendbytes(buf, VARDATA(outputbytes),
- VARSIZE(outputbytes) - VARHDRSZ);
+
+ /*
+ * If outputbytes == NULL, the send function directly appended a
+ * correctly formatted message.
+ */
+ if (outputbytes)
+ {
+ pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
+ pq_sendbytes(buf, VARDATA(outputbytes),
+ VARSIZE(outputbytes) - VARHDRSZ);
+ }
}
}
diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
index 4c894a49d5d..1b7b5b5246c 100644
--- a/src/backend/utils/adt/int.c
+++ b/src/backend/utils/adt/int.c
@@ -327,10 +327,54 @@ Datum
int4out(PG_FUNCTION_ARGS)
{
int32 arg1 = PG_GETARG_INT32(0);
- char *result = (char *) palloc(12); /* sign, 10 digits, '\0' */
+ int maxlen = 12; /* sign, 10 digits, '\0' */
- pg_ltoa(arg1, result);
- PG_RETURN_CSTRING(result);
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ {
+ /*
+ * Optimized path for output functions called as part of a larger
+ * ouput.
+ *
+ * FIXME: A good chunk of this should obviously be in helper
+ * functions.
+ */
+ InOutContext *inout = castNode(InOutContext, fcinfo->context);
+ StringInfo buf = inout->buf;
+ int prev_buflen;
+ int len;
+ uint32 len_net;
+
+ /* reserve space for length and the max string length */
+ enlargeStringInfo(buf, sizeof(uint32) + maxlen);
+
+ /* reserve space for length, to be filled out later */
+ prev_buflen = buf->len;
+ buf->len += sizeof(uint32);
+
+ /*
+ * Construct string directly in buffer, we don't have to care about
+ * encoding conversions, because we assume that every encoding
+ * embodies ascii (XXX: Is that actually true with client encodings?).
+ */
+ len = pg_ltoa(arg1, buf->data + buf->len);
+ buf->len += len;
+
+ /* update the previously reserved length */
+ len_net = pg_hton32(len);
+ memcpy(&buf->data[prev_buflen], &len_net, sizeof(uint32));
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ /*
+ * Fallback path called in any other context.
+ */
+ char *result = (char *) palloc(maxlen);
+
+ pg_ltoa(arg1, result);
+ PG_RETURN_CSTRING(result);
+ }
}
/*
@@ -351,11 +395,26 @@ Datum
int4send(PG_FUNCTION_ARGS)
{
int32 arg1 = PG_GETARG_INT32(0);
- StringInfoData buf;
- pq_begintypsend(&buf);
- pq_sendint32(&buf, arg1);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ {
+ InOutContext *inout = castNode(InOutContext, fcinfo->context);
+
+ /* length of data */
+ pq_sendint32(inout->buf, 4);
+ /* data itself */
+ pq_sendint32(inout->buf, arg1);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint32(&buf, arg1);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index c0ff51bd2fc..09913bc01f5 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -290,7 +290,45 @@ textout(PG_FUNCTION_ARGS)
{
Datum txt = PG_GETARG_DATUM(0);
- PG_RETURN_CSTRING(TextDatumGetCString(txt));
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ {
+ StringInfo buf = castNode(InOutContext, fcinfo->context)->buf;
+ text *tunpacked = pg_detoast_datum_packed(DatumGetPointer(txt));
+ int len = VARSIZE_ANY_EXHDR(tunpacked);
+ char *data = VARDATA_ANY(tunpacked);
+ char *data_converted;
+ size_t data_len;
+
+ /*
+ * Convert text output to the right encoding. For efficiency, this
+ * should really happen directly into buf. For that we would have to
+ * reserve space for the length first and fill it out after
+ * conversion.
+ *
+ * FIXME: Obviously we would need helpers for this too.
+ */
+ data_converted = pg_server_to_client(data, len);
+
+ if (data == data_converted)
+ data_len = len;
+ else
+ data_len = strlen(data_converted);
+
+ /* length */
+ pq_sendint32(buf, data_len);
+
+ /* actual data */
+ appendBinaryStringInfoNT(buf, data_converted, data_len);
+
+ if (tunpacked != DatumGetPointer(txt))
+ pfree(tunpacked);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ PG_RETURN_CSTRING(TextDatumGetCString(txt));
+ }
}
/*
--
2.46.0.519.g2e7b89e038
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2026-05-06 13:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-06 15:52 ` Re: Make printtup a bit faster Andres Freund <andres@anarazel.de>
@ 2026-05-06 16:07 ` Tom Lane <tgl@sss.pgh.pa.us>
1 sibling, 0 replies; 24+ messages in thread
From: Tom Lane @ 2026-05-06 16:07 UTC (permalink / raw)
To: Andres Freund <andres@anarazel.de>; +Cc: Andy Fan <zhihuifan1213@163.com>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Andres Freund <andres@anarazel.de> writes:
>> Puting optional context via the fcinfo looks novel to me (I have zero
>> experience to use fcinfo utility.).
> We do that in a bunch of places, e.g. for the context of window functions
> (c.f. PG_WINDOW_OBJECT() WindowObjectIsValid()).
A closely related precedent is the introduction of "soft error
reporting" for input functions. See d9f7f5d32 and follow-ons.
regards, tom lane
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2026-05-06 13:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-06 15:52 ` Re: Make printtup a bit faster Andres Freund <andres@anarazel.de>
@ 2026-05-07 12:40 ` Andy Fan <zhihuifan1213@163.com>
2026-06-02 10:25 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
1 sibling, 1 reply; 24+ messages in thread
From: Andy Fan @ 2026-05-07 12:40 UTC (permalink / raw)
To: Andres Freund <andres@anarazel.de>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Andres Freund <andres@anarazel.de> writes:
> Hi,
>
>> From Andres:
>>
>> > FWIW, I've experimented fixing this overhead before, and what I did was to
>> > pass an optional context via the fcinfo, and output / send functions could use
>> > memory allocated via that optional context object, rather than doing it
>> > allocating in CurrentMemoryContext. For the send functions that looks
>> > reasonably clean, given that it already deals with a stringinfo. For out
>> > functions it's a bit uglier, but still somewhat acceptable.
>>
>> Puting optional context via the fcinfo looks novel to me (I have zero
>> experience to use fcinfo utility.).
>
> We do that in a bunch of places, e.g. for the context of window functions
> (c.f. PG_WINDOW_OBJECT() WindowObjectIsValid()).
>
>
>> Then I'm not sure how to use the optional context, Will it be a
>> MemoryContext or a StringInfo? If MemoryContext, then how to avoid the
>> memory copy in the printtup sistuation or this method has different target.
>
> I think it'd have to be something that includes the stringinfo.
>
>
> Here's a very rough prototype for how it could look like. This clearly needs
> more helpers that I introduced, but I thought this should be enough to show
> the idea.
Yes, so optional context is really elegant. Thanks for sharing!
> A closely related precedent is the introduction of "soft error
> reporting" for input functions. See d9f7f5d32 and follow-ons.
Thanks for this example as well!
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 00:09 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2026-05-03 14:41 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
2026-05-06 13:00 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2026-05-06 15:52 ` Re: Make printtup a bit faster Andres Freund <andres@anarazel.de>
2026-05-07 12:40 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2026-06-02 10:25 ` Andy Fan <zhihuifan1213@163.com>
0 siblings, 0 replies; 24+ messages in thread
From: Andy Fan @ 2026-06-02 10:25 UTC (permalink / raw)
To: Andres Freund <andres@anarazel.de>; +Cc: Tom Lane <tgl@sss.pgh.pa.us>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Andy Fan <zhihuifan1213@163.com> writes:
Hi,
> Andres Freund <andres@anarazel.de> writes:
>> Here's a very rough prototype for how it could look like. This clearly needs
>> more helpers that I introduced, but I thought this should be enough to show
>> the idea.
>
> Yes, so optional context is really elegant. Thanks for sharing!
I continue to use optional context as the way for this optimize. Here
is the result: Port 7432 is the optimized version and port 7433 is the
master. We can see the noticeable improvement.
(feature_data-va1)> PGBENCH_RESULT_FORMAT=binary ./run.sh 7432 7433
transactions=1000 database=postgres clients=1 jobs=1 protocol=extended result_format=binary pgbench=./src/bin/pgbench/pgbench
script port latency_ms tps lat_ratio tps_ratio
int2_bench.sql 7432 3.419 292.476681 - -
int2_bench.sql 7433 4.399 227.311939 1.287 0.777
int4_bench.sql 7432 3.519 284.153068 - -
int4_bench.sql 7433 4.487 222.853492 1.275 0.784
int8_bench.sql 7432 4.525 220.970547 - -
int8_bench.sql 7433 4.574 218.632615 1.011 0.989
float4_bench.sql 7432 3.663 273.008770 - -
float4_bench.sql 7433 4.660 214.610005 1.272 0.786
float8_bench.sql 7432 3.775 264.907820 - -
float8_bench.sql 7433 4.798 208.409012 1.271 0.787
numeric_bench.sql 7432 5.715 174.968484 - -
numeric_bench.sql 7433 6.628 150.879014 1.160 0.862
text_bench.sql 7432 4.249 235.374976 - -
text_bench.sql 7433 5.275 189.576982 1.241 0.805
date_bench.sql 7432 4.870 205.342604 - -
date_bench.sql 7433 5.010 199.599045 1.029 0.972
time_bench.sql 7432 4.018 248.861954 - -
time_bench.sql 7433 5.114 195.555072 1.273 0.786
timestamp_bench.sql 7432 4.179 239.273546 - -
timestamp_bench.sql 7433 5.194 192.526840 1.243 0.805
timestamptz_bench.sql 7432 4.285 233.351970 - -
timestamptz_bench.sql 7433 5.264 189.958959 1.228 0.814
(feature_data-va1)> PGBENCH_RESULT_FORMAT=text ./run.sh 7432 7433
transactions=1000 database=postgres clients=1 jobs=1 protocol=extended result_format=text pgbench=./src/bin/pgbench/pgbench
script port latency_ms tps lat_ratio tps_ratio
int2_bench.sql 7432 3.643 274.498587 - -
int2_bench.sql 7433 4.461 224.154031 1.225 0.817
int4_bench.sql 7432 3.684 271.442388 - -
int4_bench.sql 7433 4.482 223.111396 1.217 0.822
int8_bench.sql 7432 3.839 260.464961 - -
int8_bench.sql 7433 4.878 204.981207 1.271 0.787
float4_bench.sql 7432 5.482 182.425027 - -
float4_bench.sql 7433 5.977 167.320695 1.090 0.917
float8_bench.sql 7432 6.596 151.607586 - -
float8_bench.sql 7433 7.116 140.535931 1.079 0.927
numeric_bench.sql 7432 6.762 147.878199 - -
numeric_bench.sql 7433 6.830 146.411705 1.010 0.990
text_bench.sql 7432 4.271 234.110510 - -
text_bench.sql 7433 4.904 203.915171 1.148 0.871
date_bench.sql 7432 5.473 182.707235 - -
date_bench.sql 7433 6.397 156.323668 1.169 0.856
time_bench.sql 7432 4.903 203.953267 - -
time_bench.sql 7433 5.939 168.389232 1.211 0.826
timestamp_bench.sql 7432 6.300 158.732981 - -
timestamp_bench.sql 7433 7.244 138.038000 1.150 0.870
timestamptz_bench.sql 7432 8.464 118.152459 - -
timestamptz_bench.sql 7433 9.370 106.724987 1.107 0.903
Patches and test scripts are attached.
Patch 001 and 002 comes from Andres, patch 003 uses the same way to
optimize more data type and some helper function and a bugfix for binary
format. patch 004 make pgbench support binary format, just for test
purpose.
I also attached the test scripts I used in test.tar.gz.
--
Best Regards
Andy Fan
Attachments:
[text/x-diff] v2-0001-WIP-Use-permanent-FunctionCallInfo-in-printtup.patch (2.4K, ../../87ik81p7c0.fsf@163.com/2-v2-0001-WIP-Use-permanent-FunctionCallInfo-in-printtup.patch)
download | inline diff:
From 50f8528698156aa25911ab1fa98418e94a5eb92f Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Wed, 6 May 2026 11:41:36 -0400
Subject: [PATCH v2 1/4] WIP: Use permanent FunctionCallInfo in printtup
Should probably be done similarly for COPY
---
src/backend/access/common/printtup.c | 15 +++++++++++++--
1 file changed, 13 insertions(+), 2 deletions(-)
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 616bdafd395..6fa93a6798a 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -50,6 +50,8 @@ 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 */
+ /* XXX: Would probably be faster to allocate "inline" */
+ FunctionCallInfo outstate; /* Prepared FCI for slightly faster calls */
} PrinttupAttrInfo;
typedef struct
@@ -291,6 +293,10 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unsupported format code: %d", format)));
+
+ /* both out and send funcs have one argument */
+ thisState->outstate = palloc0(SizeForFunctionCallInfo(1));
+ thisState->outstate->flinfo = &thisState->finfo;
}
}
@@ -353,12 +359,16 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
VALGRIND_CHECK_MEM_IS_DEFINED(DatumGetPointer(attr),
VARSIZE_ANY(DatumGetPointer(attr)));
+ /* fill in argument for output / send function */
+ thisState->outstate->args[0].value = attr;
+
if (thisState->format == 0)
{
/* Text output */
char *outputstr;
- outputstr = OutputFunctionCall(&thisState->finfo, attr);
+ outputstr = DatumGetCString(FunctionCallInvoke(thisState->outstate));
+ Assert(!thisState->outstate->isnull);
pq_sendcountedtext(buf, outputstr, strlen(outputstr));
}
else
@@ -366,7 +376,8 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
/* Binary output */
bytea *outputbytes;
- outputbytes = SendFunctionCall(&thisState->finfo, attr);
+ outputbytes = DatumGetByteaP(FunctionCallInvoke(thisState->outstate));
+ Assert(!thisState->outstate->isnull);
pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
pq_sendbytes(buf, VARDATA(outputbytes),
VARSIZE(outputbytes) - VARHDRSZ);
--
2.43.0
[text/x-diff] v2-0002-Mega-WIP-Optimized-out-send-path-for-printtup.patch (7.5K, ../../87ik81p7c0.fsf@163.com/3-v2-0002-Mega-WIP-Optimized-out-send-path-for-printtup.patch)
download | inline diff:
From f64830f1b2e4ee409f565fcd5636b4ecefcc8907 Mon Sep 17 00:00:00 2001
From: Andres Freund <andres@anarazel.de>
Date: Wed, 6 May 2026 11:44:26 -0400
Subject: [PATCH v2 2/4] Mega-WIP: Optimized out/send path for printtup
Discussion: https://postgr.es/m/877bpghevm.fsf@163.com
---
src/backend/access/common/printtup.c | 35 +++++++++++--
src/backend/utils/adt/int.c | 73 +++++++++++++++++++++++++---
src/backend/utils/adt/varlena.c | 40 ++++++++++++++-
src/include/nodes/miscnodes.h | 12 +++++
4 files changed, 148 insertions(+), 12 deletions(-)
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 6fa93a6798a..2e3eb8f56d3 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -63,6 +63,7 @@ typedef struct
int nattrs;
PrinttupAttrInfo *myinfo; /* Cached info about each attr */
StringInfoData buf; /* output buffer (*not* in tmpcontext) */
+ InOutContext inout; /* FunctionCallInfo->context data */
MemoryContext tmpcontext; /* Memory context for per-row workspace */
} DR_printtup;
@@ -142,6 +143,9 @@ printtup_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
FetchPortalTargetList(portal),
portal->formats);
+ myState->inout.type = T_InOutContext;
+ myState->inout.buf = &myState->buf;
+
/* ----------------
* We could set up the derived attr info at this time, but we postpone it
* until the first call of printtup, for 2 reasons:
@@ -297,6 +301,15 @@ printtup_prepare_info(DR_printtup *myState, TupleDesc typeinfo, int numAttrs)
/* both out and send funcs have one argument */
thisState->outstate = palloc0(SizeForFunctionCallInfo(1));
thisState->outstate->flinfo = &thisState->finfo;
+
+ /*
+ * The idea here is that output functions can optionally use more
+ * efficient paths if they see that the context is InOutContext, by
+ * directly appending correctly formatted output into the output
+ * buffer.
+ */
+ thisState->outstate->context = (Node *) &myState->inout;
+ thisState->outstate->nargs = 1;
}
}
@@ -369,7 +382,13 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
outputstr = DatumGetCString(FunctionCallInvoke(thisState->outstate));
Assert(!thisState->outstate->isnull);
- pq_sendcountedtext(buf, outputstr, strlen(outputstr));
+
+ /*
+ * If outputstr == NULL, the output function directly appended a
+ * correctly formatted message.
+ */
+ if (outputstr)
+ pq_sendcountedtext(buf, outputstr, strlen(outputstr));
}
else
{
@@ -378,9 +397,17 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
outputbytes = DatumGetByteaP(FunctionCallInvoke(thisState->outstate));
Assert(!thisState->outstate->isnull);
- pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
- pq_sendbytes(buf, VARDATA(outputbytes),
- VARSIZE(outputbytes) - VARHDRSZ);
+
+ /*
+ * If outputbytes == NULL, the send function directly appended a
+ * correctly formatted message.
+ */
+ if (outputbytes)
+ {
+ pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
+ pq_sendbytes(buf, VARDATA(outputbytes),
+ VARSIZE(outputbytes) - VARHDRSZ);
+ }
}
}
diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
index 01608d8ca42..de54a43c98d 100644
--- a/src/backend/utils/adt/int.c
+++ b/src/backend/utils/adt/int.c
@@ -327,10 +327,54 @@ Datum
int4out(PG_FUNCTION_ARGS)
{
int32 arg1 = PG_GETARG_INT32(0);
- char *result = (char *) palloc(12); /* sign, 10 digits, '\0' */
+ int maxlen = 12; /* sign, 10 digits, '\0' */
- pg_ltoa(arg1, result);
- PG_RETURN_CSTRING(result);
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ {
+ /*
+ * Optimized path for output functions called as part of a larger
+ * ouput.
+ *
+ * FIXME: A good chunk of this should obviously be in helper
+ * functions.
+ */
+ InOutContext *inout = castNode(InOutContext, fcinfo->context);
+ StringInfo buf = inout->buf;
+ int prev_buflen;
+ int len;
+ uint32 len_net;
+
+ /* reserve space for length and the max string length */
+ enlargeStringInfo(buf, sizeof(uint32) + maxlen);
+
+ /* reserve space for length, to be filled out later */
+ prev_buflen = buf->len;
+ buf->len += sizeof(uint32);
+
+ /*
+ * Construct string directly in buffer, we don't have to care about
+ * encoding conversions, because we assume that every encoding
+ * embodies ascii (XXX: Is that actually true with client encodings?).
+ */
+ len = pg_ltoa(arg1, buf->data + buf->len);
+ buf->len += len;
+
+ /* update the previously reserved length */
+ len_net = pg_hton32(len);
+ memcpy(&buf->data[prev_buflen], &len_net, sizeof(uint32));
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ /*
+ * Fallback path called in any other context.
+ */
+ char *result = (char *) palloc(maxlen);
+
+ pg_ltoa(arg1, result);
+ PG_RETURN_CSTRING(result);
+ }
}
/*
@@ -351,11 +395,26 @@ Datum
int4send(PG_FUNCTION_ARGS)
{
int32 arg1 = PG_GETARG_INT32(0);
- StringInfoData buf;
- pq_begintypsend(&buf);
- pq_sendint32(&buf, arg1);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ {
+ InOutContext *inout = castNode(InOutContext, fcinfo->context);
+
+ /* length of data */
+ pq_sendint32(inout->buf, 4);
+ /* data itself */
+ pq_sendint32(inout->buf, arg1);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint32(&buf, arg1);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index 0c6d3ba4d22..4948ced7dec 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -290,7 +290,45 @@ textout(PG_FUNCTION_ARGS)
{
Datum txt = PG_GETARG_DATUM(0);
- PG_RETURN_CSTRING(TextDatumGetCString(txt));
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ {
+ StringInfo buf = castNode(InOutContext, fcinfo->context)->buf;
+ text *tunpacked = pg_detoast_datum_packed(DatumGetPointer(txt));
+ int len = VARSIZE_ANY_EXHDR(tunpacked);
+ char *data = VARDATA_ANY(tunpacked);
+ char *data_converted;
+ size_t data_len;
+
+ /*
+ * Convert text output to the right encoding. For efficiency, this
+ * should really happen directly into buf. For that we would have to
+ * reserve space for the length first and fill it out after
+ * conversion.
+ *
+ * FIXME: Obviously we would need helpers for this too.
+ */
+ data_converted = pg_server_to_client(data, len);
+
+ if (data == data_converted)
+ data_len = len;
+ else
+ data_len = strlen(data_converted);
+
+ /* length */
+ pq_sendint32(buf, data_len);
+
+ /* actual data */
+ appendBinaryStringInfoNT(buf, data_converted, data_len);
+
+ if (tunpacked != DatumGetPointer(txt))
+ pfree(tunpacked);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ PG_RETURN_CSTRING(TextDatumGetCString(txt));
+ }
}
/*
diff --git a/src/include/nodes/miscnodes.h b/src/include/nodes/miscnodes.h
index ec833001ab0..b3c189a5c0c 100644
--- a/src/include/nodes/miscnodes.h
+++ b/src/include/nodes/miscnodes.h
@@ -54,4 +54,16 @@ typedef struct ErrorSaveContext
((escontext) != NULL && IsA(escontext, ErrorSaveContext) && \
((ErrorSaveContext *) (escontext))->error_occurred)
+
+/*
+ * Type optionally passed to input/receive/output/send functions that allows
+ * those functions to opt into more efficient ways of performing their work
+ * (mainly reducing allocations & copies).
+ */
+typedef struct InOutContext
+{
+ NodeTag type;
+ StringInfo buf;
+} InOutContext;
+
#endif /* MISCNODES_H */
--
2.43.0
[text/x-diff] v2-0003-Optimize-more-data-type-for-less-memory-copy-with.patch (19.4K, ../../87ik81p7c0.fsf@163.com/4-v2-0003-Optimize-more-data-type-for-less-memory-copy-with.patch)
download | inline diff:
From 4cae157489e3c923a874f37aec07099d75f0cefe Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Tue, 2 Jun 2026 17:37:29 +0800
Subject: [PATCH v2 3/4] Optimize more data type for less memory copy with
optional context.
---
src/backend/access/common/printtup.c | 8 ++-
src/backend/utils/adt/date.c | 32 +++++++----
src/backend/utils/adt/float.c | 62 ++++++++++++++++-----
src/backend/utils/adt/int.c | 82 +++++++++++++++-------------
src/backend/utils/adt/int8.c | 40 ++++++++++----
src/backend/utils/adt/numeric.c | 46 ++++++++++++----
src/backend/utils/adt/timestamp.c | 50 ++++++++++++-----
src/backend/utils/adt/varlena.c | 52 ++++++++----------
src/include/libpq/pqformat.h | 61 +++++++++++++++++++++
src/include/utils/builtins.h | 24 ++++++++
10 files changed, 325 insertions(+), 132 deletions(-)
diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 2e3eb8f56d3..ab625736ac1 100644
--- a/src/backend/access/common/printtup.c
+++ b/src/backend/access/common/printtup.c
@@ -393,17 +393,19 @@ printtup(TupleTableSlot *slot, DestReceiver *self)
else
{
/* Binary output */
+ Datum outputdatum;
bytea *outputbytes;
- outputbytes = DatumGetByteaP(FunctionCallInvoke(thisState->outstate));
+ outputdatum = FunctionCallInvoke(thisState->outstate);
Assert(!thisState->outstate->isnull);
/*
- * If outputbytes == NULL, the send function directly appended a
+ * If outputdatum == 0, the send function directly appended a
* correctly formatted message.
*/
- if (outputbytes)
+ if (outputdatum)
{
+ outputbytes = DatumGetByteaP(outputdatum);
pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
pq_sendbytes(buf, VARDATA(outputbytes),
VARSIZE(outputbytes) - VARHDRSZ);
diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 7f746dd84c9..43284d43fda 100644
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -180,7 +180,6 @@ Datum
date_out(PG_FUNCTION_ARGS)
{
DateADT date = PG_GETARG_DATEADT(0);
- char *result;
struct pg_tm tt,
*tm = &tt;
char buf[MAXDATELEN + 1];
@@ -194,8 +193,10 @@ date_out(PG_FUNCTION_ARGS)
EncodeDateOnly(tm, DateStyle, buf);
}
- result = pstrdup(buf);
- PG_RETURN_CSTRING(result);
+ if (pg_send_inout_text(fcinfo, buf, strlen(buf)))
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_CSTRING(pstrdup(buf));
}
/*
@@ -1606,7 +1607,6 @@ Datum
time_out(PG_FUNCTION_ARGS)
{
TimeADT time = PG_GETARG_TIMEADT(0);
- char *result;
struct pg_tm tt,
*tm = &tt;
fsec_t fsec;
@@ -1615,8 +1615,10 @@ time_out(PG_FUNCTION_ARGS)
time2tm(time, tm, &fsec);
EncodeTimeOnly(tm, fsec, false, 0, DateStyle, buf);
- result = pstrdup(buf);
- PG_RETURN_CSTRING(result);
+ if (pg_send_inout_text(fcinfo, buf, strlen(buf)))
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_CSTRING(pstrdup(buf));
}
/*
@@ -1652,11 +1654,21 @@ Datum
time_send(PG_FUNCTION_ARGS)
{
TimeADT time = PG_GETARG_TIMEADT(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendint64(&buf, time);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ pq_sendint64_field(buf, time);
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint64(&buf, time);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
Datum
diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c
index 362c29ab803..161d5593f5f 100644
--- a/src/backend/utils/adt/float.c
+++ b/src/backend/utils/adt/float.c
@@ -24,6 +24,7 @@
#include "common/shortest_dec.h"
#include "libpq/pqformat.h"
#include "utils/array.h"
+#include "utils/builtins.h"
#include "utils/float.h"
#include "utils/fmgrprotos.h"
#include "utils/sortsupport.h"
@@ -360,17 +361,18 @@ Datum
float4out(PG_FUNCTION_ARGS)
{
float4 num = PG_GETARG_FLOAT4(0);
- char *ascii = (char *) palloc(32);
+ char ascii[32];
int ndig = FLT_DIG + extra_float_digits;
if (extra_float_digits > 0)
- {
float_to_shortest_decimal_buf(num, ascii);
- PG_RETURN_CSTRING(ascii);
- }
+ else
+ (void) pg_strfromd(ascii, 32, ndig, num);
- (void) pg_strfromd(ascii, 32, ndig, num);
- PG_RETURN_CSTRING(ascii);
+ if (pg_send_inout_text(fcinfo, ascii, strlen(ascii)))
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_CSTRING(pstrdup(ascii));
}
/*
@@ -391,11 +393,21 @@ Datum
float4send(PG_FUNCTION_ARGS)
{
float4 num = PG_GETARG_FLOAT4(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendfloat4(&buf, num);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ pq_sendfloat4_field(buf, num);
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendfloat4(&buf, num);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
/*
@@ -563,8 +575,18 @@ Datum
float8out(PG_FUNCTION_ARGS)
{
float8 num = PG_GETARG_FLOAT8(0);
+ char ascii[32];
+ int ndig = DBL_DIG + extra_float_digits;
+
+ if (extra_float_digits > 0)
+ double_to_shortest_decimal_buf(num, ascii);
+ else
+ (void) pg_strfromd(ascii, 32, ndig, num);
- PG_RETURN_CSTRING(float8out_internal(num));
+ if (pg_send_inout_text(fcinfo, ascii, strlen(ascii)))
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_CSTRING(pstrdup(ascii));
}
/*
@@ -608,11 +630,21 @@ Datum
float8send(PG_FUNCTION_ARGS)
{
float8 num = PG_GETARG_FLOAT8(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendfloat8(&buf, num);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ pq_sendfloat8_field(buf, num);
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendfloat8(&buf, num);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
index de54a43c98d..9a3fda0403a 100644
--- a/src/backend/utils/adt/int.c
+++ b/src/backend/utils/adt/int.c
@@ -74,10 +74,27 @@ Datum
int2out(PG_FUNCTION_ARGS)
{
int16 arg1 = PG_GETARG_INT16(0);
- char *result = (char *) palloc(7); /* sign, 5 digits, '\0' */
+ int maxlen = 7; /* sign, 5 digits, '\0' */
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pg_itoa(arg1, result);
- PG_RETURN_CSTRING(result);
+ if (buf)
+ {
+ int offset;
+ int len;
+
+ len = pg_itoa(arg1, pq_begincountedfield(buf, maxlen, &offset));
+ buf->len += len;
+ pq_endcountedfield(buf, offset);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ char *result = (char *) palloc(maxlen);
+
+ pg_itoa(arg1, result);
+ PG_RETURN_CSTRING(result);
+ }
}
/*
@@ -98,11 +115,21 @@ Datum
int2send(PG_FUNCTION_ARGS)
{
int16 arg1 = PG_GETARG_INT16(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendint16(&buf, arg1);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ pq_sendint16_field(buf, arg1);
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint16(&buf, arg1);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
/*
@@ -328,40 +355,22 @@ int4out(PG_FUNCTION_ARGS)
{
int32 arg1 = PG_GETARG_INT32(0);
int maxlen = 12; /* sign, 10 digits, '\0' */
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ if (buf)
{
- /*
- * Optimized path for output functions called as part of a larger
- * ouput.
- *
- * FIXME: A good chunk of this should obviously be in helper
- * functions.
- */
- InOutContext *inout = castNode(InOutContext, fcinfo->context);
- StringInfo buf = inout->buf;
- int prev_buflen;
+ /* Optimized path for output functions called as part of a larger output. */
+ int offset;
int len;
- uint32 len_net;
-
- /* reserve space for length and the max string length */
- enlargeStringInfo(buf, sizeof(uint32) + maxlen);
-
- /* reserve space for length, to be filled out later */
- prev_buflen = buf->len;
- buf->len += sizeof(uint32);
/*
* Construct string directly in buffer, we don't have to care about
* encoding conversions, because we assume that every encoding
* embodies ascii (XXX: Is that actually true with client encodings?).
*/
- len = pg_ltoa(arg1, buf->data + buf->len);
+ len = pg_ltoa(arg1, pq_begincountedfield(buf, maxlen, &offset));
buf->len += len;
-
- /* update the previously reserved length */
- len_net = pg_hton32(len);
- memcpy(&buf->data[prev_buflen], &len_net, sizeof(uint32));
+ pq_endcountedfield(buf, offset);
PG_RETURN_VOID();
}
@@ -395,16 +404,11 @@ Datum
int4send(PG_FUNCTION_ARGS)
{
int32 arg1 = PG_GETARG_INT32(0);
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ if (buf)
{
- InOutContext *inout = castNode(InOutContext, fcinfo->context);
-
- /* length of data */
- pq_sendint32(inout->buf, 4);
- /* data itself */
- pq_sendint32(inout->buf, arg1);
-
+ pq_sendint32_field(buf, arg1);
PG_RETURN_VOID();
}
else
diff --git a/src/backend/utils/adt/int8.c b/src/backend/utils/adt/int8.c
index 9b429da86d9..184927f4438 100644
--- a/src/backend/utils/adt/int8.c
+++ b/src/backend/utils/adt/int8.c
@@ -63,19 +63,37 @@ Datum
int8out(PG_FUNCTION_ARGS)
{
int64 val = PG_GETARG_INT64(0);
- char buf[MAXINT8LEN + 1];
- char *result;
- int len;
+ int maxlen = MAXINT8LEN + 1;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- len = pg_lltoa(val, buf) + 1;
+ if (buf)
+ {
+ int offset;
+ int len;
- /*
- * Since the length is already known, we do a manual palloc() and memcpy()
- * to avoid the strlen() call that would otherwise be done in pstrdup().
- */
- result = palloc(len);
- memcpy(result, buf, len);
- PG_RETURN_CSTRING(result);
+ len = pg_lltoa(val, pq_begincountedfield(buf, maxlen, &offset));
+ buf->len += len;
+ pq_endcountedfield(buf, offset);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ char buf[MAXINT8LEN + 1];
+ char *result;
+ int len;
+
+ len = pg_lltoa(val, buf) + 1;
+
+ /*
+ * Since the length is already known, we do a manual palloc() and
+ * memcpy() to avoid the strlen() call that would otherwise be done in
+ * pstrdup().
+ */
+ result = palloc(len);
+ memcpy(result, buf, len);
+ PG_RETURN_CSTRING(result);
+ }
}
/*
diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index cb23dfe9b95..1264a0bb0ff 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -808,11 +808,16 @@ numeric_out(PG_FUNCTION_ARGS)
if (NUMERIC_IS_SPECIAL(num))
{
if (NUMERIC_IS_PINF(num))
- PG_RETURN_CSTRING(pstrdup("Infinity"));
+ str = "Infinity";
else if (NUMERIC_IS_NINF(num))
- PG_RETURN_CSTRING(pstrdup("-Infinity"));
+ str = "-Infinity";
else
- PG_RETURN_CSTRING(pstrdup("NaN"));
+ str = "NaN";
+
+ if (pg_send_inout_text(fcinfo, str, strlen(str)))
+ PG_RETURN_VOID();
+
+ PG_RETURN_CSTRING(pstrdup(str));
}
/*
@@ -822,6 +827,9 @@ numeric_out(PG_FUNCTION_ARGS)
str = get_str_from_var(&x);
+ if (pg_send_inout_text(fcinfo, str, strlen(str)))
+ PG_RETURN_VOID();
+
PG_RETURN_CSTRING(str);
}
@@ -1147,21 +1155,37 @@ numeric_send(PG_FUNCTION_ARGS)
{
Numeric num = PG_GETARG_NUMERIC(0);
NumericVar x;
- StringInfoData buf;
+ StringInfo buf;
+ StringInfoData localbuf;
+ bool inout;
int i;
init_var_from_num(num, &x);
- pq_begintypsend(&buf);
+ buf = pg_get_inout_context_buf(fcinfo);
+ inout = buf != NULL;
+ if (inout)
+ {
+ /* length of data */
+ pq_sendint32(buf, (4 + x.ndigits) * sizeof(int16));
+ }
+ else
+ {
+ pq_begintypsend(&localbuf);
+ buf = &localbuf;
+ }
- pq_sendint16(&buf, x.ndigits);
- pq_sendint16(&buf, x.weight);
- pq_sendint16(&buf, x.sign);
- pq_sendint16(&buf, x.dscale);
+ pq_sendint16(buf, x.ndigits);
+ pq_sendint16(buf, x.weight);
+ pq_sendint16(buf, x.sign);
+ pq_sendint16(buf, x.dscale);
for (i = 0; i < x.ndigits; i++)
- pq_sendint16(&buf, x.digits[i]);
+ pq_sendint16(buf, x.digits[i]);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (inout)
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_BYTEA_P(pq_endtypsend(&localbuf));
}
diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index a20e7ea1d11..0c0b7af700a 100644
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -227,7 +227,6 @@ Datum
timestamp_out(PG_FUNCTION_ARGS)
{
Timestamp timestamp = PG_GETARG_TIMESTAMP(0);
- char *result;
struct pg_tm tt,
*tm = &tt;
fsec_t fsec;
@@ -242,8 +241,10 @@ timestamp_out(PG_FUNCTION_ARGS)
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
- result = pstrdup(buf);
- PG_RETURN_CSTRING(result);
+ if (pg_send_inout_text(fcinfo, buf, strlen(buf)))
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_CSTRING(pstrdup(buf));
}
/*
@@ -286,11 +287,21 @@ Datum
timestamp_send(PG_FUNCTION_ARGS)
{
Timestamp timestamp = PG_GETARG_TIMESTAMP(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendint64(&buf, timestamp);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ pq_sendint64_field(buf, timestamp);
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint64(&buf, timestamp);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
Datum
@@ -773,7 +784,6 @@ Datum
timestamptz_out(PG_FUNCTION_ARGS)
{
TimestampTz dt = PG_GETARG_TIMESTAMPTZ(0);
- char *result;
int tz;
struct pg_tm tt,
*tm = &tt;
@@ -790,8 +800,10 @@ timestamptz_out(PG_FUNCTION_ARGS)
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("timestamp out of range")));
- result = pstrdup(buf);
- PG_RETURN_CSTRING(result);
+ if (pg_send_inout_text(fcinfo, buf, strlen(buf)))
+ PG_RETURN_VOID();
+ else
+ PG_RETURN_CSTRING(pstrdup(buf));
}
/*
@@ -835,11 +847,21 @@ Datum
timestamptz_send(PG_FUNCTION_ARGS)
{
TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendint64(&buf, timestamp);
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ pq_sendint64_field(buf, timestamp);
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendint64(&buf, timestamp);
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
Datum
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index 4948ced7dec..5dac5b39f11 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -289,37 +289,15 @@ Datum
textout(PG_FUNCTION_ARGS)
{
Datum txt = PG_GETARG_DATUM(0);
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ if (buf)
{
- StringInfo buf = castNode(InOutContext, fcinfo->context)->buf;
text *tunpacked = pg_detoast_datum_packed(DatumGetPointer(txt));
int len = VARSIZE_ANY_EXHDR(tunpacked);
char *data = VARDATA_ANY(tunpacked);
- char *data_converted;
- size_t data_len;
-
- /*
- * Convert text output to the right encoding. For efficiency, this
- * should really happen directly into buf. For that we would have to
- * reserve space for the length first and fill it out after
- * conversion.
- *
- * FIXME: Obviously we would need helpers for this too.
- */
- data_converted = pg_server_to_client(data, len);
-
- if (data == data_converted)
- data_len = len;
- else
- data_len = strlen(data_converted);
-
- /* length */
- pq_sendint32(buf, data_len);
-
- /* actual data */
- appendBinaryStringInfoNT(buf, data_converted, data_len);
+ pq_sendcountedtext(buf, data, len);
if (tunpacked != DatumGetPointer(txt))
pfree(tunpacked);
@@ -356,11 +334,27 @@ Datum
textsend(PG_FUNCTION_ARGS)
{
text *t = PG_GETARG_TEXT_PP(0);
- StringInfoData buf;
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
- pq_begintypsend(&buf);
- pq_sendtext(&buf, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
- PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ if (buf)
+ {
+ int offset;
+
+ /* reserve space for length, to be filled out after conversion */
+ (void) pq_begincountedfield(buf, 0, &offset);
+ pq_sendtext(buf, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
+ pq_endcountedfield(buf, offset);
+
+ PG_RETURN_VOID();
+ }
+ else
+ {
+ StringInfoData buf;
+
+ pq_begintypsend(&buf);
+ pq_sendtext(&buf, VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t));
+ PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+ }
}
diff --git a/src/include/libpq/pqformat.h b/src/include/libpq/pqformat.h
index bc4ab1381a9..d40f36b5fbc 100644
--- a/src/include/libpq/pqformat.h
+++ b/src/include/libpq/pqformat.h
@@ -94,6 +94,32 @@ pq_writeint64(StringInfoData *pg_restrict buf, uint64 i)
buf->len += sizeof(uint64);
}
+/*
+ * Reserve a length-prefixed field in a StringInfo buffer, returning the
+ * location at which the payload should be written. The payload length is
+ * filled in by pq_endcountedfield().
+ */
+static inline char *
+pq_begincountedfield(StringInfo buf, int maxlen, int *offset)
+{
+ enlargeStringInfo(buf, sizeof(uint32) + maxlen);
+
+ *offset = buf->len;
+ buf->len += sizeof(uint32);
+
+ return buf->data + buf->len;
+}
+
+/* Fill in the length of a field started by pq_begincountedfield(). */
+static inline void
+pq_endcountedfield(StringInfo buf, int offset)
+{
+ int len = buf->len - offset - sizeof(uint32);
+ uint32 len_net = pg_hton32(len);
+
+ memcpy(&buf->data[offset], &len_net, sizeof(uint32));
+}
+
/*
* Append a null-terminated text string (with conversion) to a buffer with
* preallocated space.
@@ -187,6 +213,41 @@ pq_sendint(StringInfo buf, uint32 i, int b)
}
}
+/* append length-prefixed binary fields to a StringInfo buffer */
+static inline void
+pq_sendint16_field(StringInfo buf, uint16 i)
+{
+ pq_sendint32(buf, sizeof(uint16));
+ pq_sendint16(buf, i);
+}
+
+static inline void
+pq_sendint32_field(StringInfo buf, uint32 i)
+{
+ pq_sendint32(buf, sizeof(uint32));
+ pq_sendint32(buf, i);
+}
+
+static inline void
+pq_sendint64_field(StringInfo buf, uint64 i)
+{
+ pq_sendint32(buf, sizeof(uint64));
+ pq_sendint64(buf, i);
+}
+
+static inline void
+pq_sendfloat4_field(StringInfo buf, float4 f)
+{
+ pq_sendint32(buf, sizeof(float4));
+ pq_sendfloat4(buf, f);
+}
+
+static inline void
+pq_sendfloat8_field(StringInfo buf, float8 f)
+{
+ pq_sendint32(buf, sizeof(float8));
+ pq_sendfloat8(buf, f);
+}
extern void pq_begintypsend(StringInfo buf);
extern bytea *pq_endtypsend(StringInfo buf);
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index b6a11bfa288..0bf228a746b 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -15,12 +15,36 @@
#define BUILTINS_H
#include "fmgr.h"
+#include "libpq/pqformat.h"
+#include "nodes/miscnodes.h"
#include "nodes/nodes.h"
#include "utils/fmgrprotos.h"
/* Sign + the most decimal digits an 8-byte number could have */
#define MAXINT8LEN 20
+/* Helpers for output/send functions using InOutContext. */
+static inline StringInfo
+pg_get_inout_context_buf(FunctionCallInfo fcinfo)
+{
+ if (fcinfo->context && IsA(fcinfo->context, InOutContext))
+ return castNode(InOutContext, fcinfo->context)->buf;
+
+ return NULL;
+}
+
+static inline bool
+pg_send_inout_text(FunctionCallInfo fcinfo, const char *str, int slen)
+{
+ StringInfo buf = pg_get_inout_context_buf(fcinfo);
+
+ if (!buf)
+ return false;
+
+ pq_sendcountedtext(buf, str, slen);
+ return true;
+}
+
/* bool.c */
extern bool parse_bool(const char *value, bool *result);
extern bool parse_bool_with_len(const char *value, size_t len, bool *result);
--
2.43.0
[text/x-diff] v2-0004-Let-pgbench-support-binary-format.patch (3.8K, ../../87ik81p7c0.fsf@163.com/5-v2-0004-Let-pgbench-support-binary-format.patch)
download | inline diff:
From 4be7ac289e263a14b82009ff5adeba3a82d46174 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@163.com>
Date: Tue, 2 Jun 2026 18:08:13 +0800
Subject: [PATCH v2 4/4] Let pgbench support binary format.
---
src/bin/pgbench/pgbench.c | 29 +++++++++++++++++++++++++++--
1 file changed, 27 insertions(+), 2 deletions(-)
diff --git a/src/bin/pgbench/pgbench.c b/src/bin/pgbench/pgbench.c
index 0b2bb9340b5..533a1732158 100644
--- a/src/bin/pgbench/pgbench.c
+++ b/src/bin/pgbench/pgbench.c
@@ -722,6 +722,16 @@ typedef enum QueryMode
static QueryMode querymode = QUERY_SIMPLE;
static const char *const QUERYMODE[] = {"simple", "extended", "prepared"};
+typedef enum ResultFormat
+{
+ RESULT_FORMAT_TEXT,
+ RESULT_FORMAT_BINARY,
+ NUM_RESULT_FORMAT
+} ResultFormat;
+
+static ResultFormat result_format = RESULT_FORMAT_TEXT;
+static const char *const RESULT_FORMAT[] = {"text", "binary"};
+
/*
* struct Command represents one command in a script.
*
@@ -965,6 +975,8 @@ usage(void)
" --max-tries=NUM max number of tries to run transaction (default: 1)\n"
" --progress-timestamp use Unix epoch timestamps for progress\n"
" --random-seed=SEED set random seed (\"time\", \"rand\", integer)\n"
+ " --result-format=text|binary\n"
+ " result format for extended/prepared protocol (default: text)\n"
" --sampling-rate=NUM fraction of transactions to log (e.g., 0.01 for 1%%)\n"
" --show-script=NAME show builtin script code, then exit\n"
" --verbose-errors print messages of all errors\n"
@@ -3173,7 +3185,7 @@ sendCommand(CState *st, Command *command)
pg_log_debug("client %d sending %s", st->id, sql);
r = PQsendQueryParams(st->con, sql, command->argc - 1,
- NULL, params, NULL, NULL, 0);
+ NULL, params, NULL, NULL, result_format);
}
else if (querymode == QUERY_PREPARED)
{
@@ -3184,7 +3196,7 @@ sendCommand(CState *st, Command *command)
pg_log_debug("client %d sending %s", st->id, command->prepname);
r = PQsendQueryPrepared(st->con, command->prepname, command->argc - 1,
- params, NULL, NULL, 0);
+ params, NULL, NULL, result_format);
}
else /* unknown sql mode */
r = 0;
@@ -6470,6 +6482,7 @@ printResults(StatsData *total,
printf("partition method: %s\npartitions: %d\n",
PARTITION_METHOD[partition_method], partitions);
printf("query mode: %s\n", QUERYMODE[querymode]);
+ printf("result format: %s\n", RESULT_FORMAT[result_format]);
printf("number of clients: %d\n", nclients);
printf("number of threads: %d\n", nthreads);
@@ -6778,6 +6791,7 @@ main(int argc, char **argv)
{"exit-on-abort", no_argument, NULL, 16},
{"debug", no_argument, NULL, 17},
{"continue-on-error", no_argument, NULL, 18},
+ {"result-format", required_argument, NULL, 19},
{NULL, 0, NULL, 0}
};
@@ -7138,6 +7152,14 @@ main(int argc, char **argv)
benchmarking_option_set = true;
continue_on_error = true;
break;
+ case 19: /* result-format */
+ benchmarking_option_set = true;
+ for (result_format = 0; result_format < NUM_RESULT_FORMAT; result_format++)
+ if (strcmp(optarg, RESULT_FORMAT[result_format]) == 0)
+ break;
+ if (result_format >= NUM_RESULT_FORMAT)
+ pg_fatal("invalid result format: \"%s\"", optarg);
+ break;
default:
/* getopt_long already emitted a complaint */
pg_log_error_hint("Try \"%s --help\" for more information.", progname);
@@ -7169,6 +7191,9 @@ main(int argc, char **argv)
if (total_weight == 0 && !is_init_mode)
pg_fatal("total script weight must not be zero");
+ if (result_format == RESULT_FORMAT_BINARY && querymode == QUERY_SIMPLE)
+ pg_fatal("binary result format requires extended or prepared query mode");
+
/* show per script stats if several scripts are used */
if (num_scripts > 1)
per_script_stats = true;
--
2.43.0
[application/gzip] test.tar.gz (1.8K, ../../87ik81p7c0.fsf@163.com/6-test.tar.gz)
download
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
@ 2024-08-30 16:20 ` Andreas Karlsson <andreas@proxel.se>
2024-09-11 01:02 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2 siblings, 1 reply; 24+ messages in thread
From: Andreas Karlsson @ 2024-08-30 16:20 UTC (permalink / raw)
To: David Rowley <dgrowleyml@gmail.com>; Andy Fan <zhihuifan1213@163.com>; +Cc: pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
On 8/29/24 1:51 PM, David Rowley wrote:
> I had planned to work on this for PG18, but I'd be happy for some
> assistance if you're willing.
I am interested in working on this, unless Andy Fan wants to do this
work. :) I believe that optimizing the out, in and send functions would
be worth the pain. I get Tom's objections but I do not think adding a
small check would add much overhead compared to the gains we can get.
And given that all of in, out and send could be optimized I do not like
the idea of duplicating all three in the catalog.
David, have you given any thought on the cleanest way to check for if
the new API or the old is the be used for these functions? If not I can
figure out something myself, just wondering if you already had something
in mind.
Andreas
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 16:20 ` Re: Make printtup a bit faster Andreas Karlsson <andreas@proxel.se>
@ 2024-09-11 01:02 ` Andy Fan <zhihuifan1213@163.com>
2024-09-11 01:18 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
0 siblings, 1 reply; 24+ messages in thread
From: Andy Fan @ 2024-09-11 01:02 UTC (permalink / raw)
To: Andreas Karlsson <andreas@proxel.se>; +Cc: David Rowley <dgrowleyml@gmail.com>; pgsql-hackers; Tom Lane <tgl@sss.pgh.pa.us>
Hello David & Andreas,
> On 8/29/24 1:51 PM, David Rowley wrote:
>> I had planned to work on this for PG18, but I'd be happy for some
>> assistance if you're willing.
>
> I am interested in working on this, unless Andy Fan wants to do this
> work. :) I believe that optimizing the out, in and send functions would
> be worth the pain. I get Tom's objections but I do not think adding a
> small check would add much overhead compared to the gains we can get.
Just to be clearer, I'd like work on the out function only due to my
internal assignment. (Since David planned it for PG18, so it is better
say things clearer eariler). 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.
select count(*), count(distinct typoutput) from pg_type;
count | count
-------+-------
621 | 97
(1 row)
select typoutput, count(*) from pg_type group by typoutput having
count(*) > 1 order by 2 desc;
typoutput | count
-----------------+-------
array_out | 296
record_out | 214
multirange_out | 6
range_out | 6
varcharout | 3
int4out | 2
timestamptz_out | 2
nameout | 2
textout | 2
(9 rows)
--
Best Regards
Andy Fan
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 16:20 ` Re: Make printtup a bit faster Andreas Karlsson <andreas@proxel.se>
2024-09-11 01:02 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
@ 2024-09-11 01:18 ` Tom Lane <tgl@sss.pgh.pa.us>
2024-09-12 10:31 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
0 siblings, 1 reply; 24+ messages in thread
From: Tom Lane @ 2024-09-11 01:18 UTC (permalink / raw)
To: Andy Fan <zhihuifan1213@163.com>; +Cc: Andreas Karlsson <andreas@proxel.se>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
Andy Fan <zhihuifan1213@163.com> writes:
> Just to be clearer, I'd like work on the out function only due to my
> internal assignment. (Since David planned it for PG18, so it is better
> say things clearer eariler). 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).
regards, tom lane
^ permalink raw reply [nested|flat] 24+ messages in thread
* Re: Make printtup a bit faster
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` Re: Make printtup a bit faster David Rowley <dgrowleyml@gmail.com>
2024-08-30 16:20 ` Re: Make printtup a bit faster Andreas Karlsson <andreas@proxel.se>
2024-09-11 01:02 ` Re: Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-09-11 01:18 ` Re: Make printtup a bit faster Tom Lane <tgl@sss.pgh.pa.us>
@ 2024-09-12 10:31 ` Andy Fan <zhihuifan1213@163.com>
0 siblings, 0 replies; 24+ messages in thread
From: Andy Fan @ 2024-09-12 10:31 UTC (permalink / raw)
To: Tom Lane <tgl@sss.pgh.pa.us>; +Cc: Andreas Karlsson <andreas@proxel.se>; David Rowley <dgrowleyml@gmail.com>; pgsql-hackers
>> ... 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
Attachments:
[text/x-diff] v20240912-0003-add-unlikely-hint-for-enlargeStringInfo.patch (1.3K, ../../87seu5duya.fsf@163.com/2-v20240912-0003-add-unlikely-hint-for-enlargeStringInfo.patch)
download | inline diff:
From 4fa462d02902e7ac278a312ad60f43c52f403753 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@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
[text/x-diff] v20240912-0001-Refactor-float8out_internval-for-better-pe.patch (6.3K, ../../87seu5duya.fsf@163.com/3-v20240912-0001-Refactor-float8out_internval-for-better-pe.patch)
download | inline diff:
From dc1475195f1350745e45a5b7db381354f99d83da Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@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
[text/x-diff] v20240912-0002-Continue-to-remove-some-unnecesary-strlen-.patch (2.4K, ../../87seu5duya.fsf@163.com/4-v20240912-0002-Continue-to-remove-some-unnecesary-strlen-.patch)
download | inline diff:
From 8b4ba05a9c0e767c1d053365e70966e1d9544179 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@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
[text/x-diff] v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch (29.9K, ../../87seu5duya.fsf@163.com/5-v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch)
download | inline diff:
From bbeb539f85c80ffe44f71c12aabd725c8b29ead4 Mon Sep 17 00:00:00 2001
From: Andy Fan <zhihuifan1213@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
^ permalink raw reply [nested|flat] 24+ messages in thread
end of thread, other threads:[~2026-06-02 10:25 UTC | newest]
Thread overview: 24+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2024-08-29 09:40 Make printtup a bit faster Andy Fan <zhihuifan1213@163.com>
2024-08-29 11:51 ` David Rowley <dgrowleyml@gmail.com>
2024-08-29 15:33 ` Tom Lane <tgl@sss.pgh.pa.us>
2024-08-30 00:31 ` David Rowley <dgrowleyml@gmail.com>
2024-08-30 05:00 ` Andy Fan <zhihuifan1213@163.com>
2024-09-02 03:18 ` Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:09 ` Andy Fan <zhihuifan1213@163.com>
2024-08-30 00:38 ` David Rowley <dgrowleyml@gmail.com>
2024-08-30 01:04 ` Andy Fan <zhihuifan1213@163.com>
2024-08-30 01:13 ` David Rowley <dgrowleyml@gmail.com>
2024-08-30 01:34 ` Andy Fan <zhihuifan1213@163.com>
2026-05-03 14:41 ` Andy Fan <zhihuifan1213@163.com>
2026-05-04 04:38 ` Tom Lane <tgl@sss.pgh.pa.us>
2026-05-04 08:26 ` Andres Freund <andres@anarazel.de>
2026-05-04 13:09 ` Tom Lane <tgl@sss.pgh.pa.us>
2026-05-06 13:00 ` Andy Fan <zhihuifan1213@163.com>
2026-05-06 15:52 ` Andres Freund <andres@anarazel.de>
2026-05-06 16:07 ` Tom Lane <tgl@sss.pgh.pa.us>
2026-05-07 12:40 ` Andy Fan <zhihuifan1213@163.com>
2026-06-02 10:25 ` Andy Fan <zhihuifan1213@163.com>
2024-08-30 16:20 ` Andreas Karlsson <andreas@proxel.se>
2024-09-11 01:02 ` Andy Fan <zhihuifan1213@163.com>
2024-09-11 01:18 ` Tom Lane <tgl@sss.pgh.pa.us>
2024-09-12 10:31 ` Andy Fan <zhihuifan1213@163.com>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox