agora inbox for pgsql-hackers@postgresql.org  

help / color / mirror / Atom feed

[PATCH v14 2/2] handle relation statistics correctly during rewrites
513+ messages / 2 participants
[nested] [flat]

* [PATCH v14 2/2] handle relation statistics correctly during rewrites
@ 2025-11-04 13:52  Bertrand Drouvot <bertranddrouvot.pg@gmail.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Bertrand Drouvot @ 2025-11-04 13:52 UTC (permalink / raw)

Now that PGSTAT_KIND_RELATION is keyed by refilenode, we need to handle rewrites.

To do so, this patch:

- Adds PgStat_PendingRewrite, a new struct to track rewrite operations within
a transaction, storing the old locator, new locator, and original locator (for
rewrite chains). This allows stats to be copied from the original location to
the final location at commit time.

- Adds a new function, pgstat_mark_rewrite(), called when a table rewrite begins.
It records the rewrite operation in a local list and detects rewrite chains by
checking if the old_locator matches any existing new_locator, preserving the
chain's original_locator.

- Modifies pgstat_copy_relation_stats(), to accept RelFileLocators instead of
Relations, with a new increment parameter to accumulate stats (needed for rewrite
chains with DML between rewrites).

- Ensures that AtEOXact_PgStat_Relations(), AtPrepare_PgStat_Relations(),
pgstat_twophase_postcommit()/postabort() pgstat_drop_relation() handle the
PgStat_PendingRewrite list correctly.

Note that due to the new flush call in pgstat_twophase_postcommit() we can not
call GetCurrentTransactionStopTimestamp() in pgstat_relation_flush_cb(). So,
adding a check to handle this special case and call GetCurrentTimestamp() instead.
Note that we'd call GetCurrentTimestamp() only if there is a rewrite, so that
the GetCurrentTimestamp() extra cost should be negligible. Another solution
could be to trigger the flush from FinishPreparedTransaction() but that's not
worth the extra complexity.

The new pending_rewrites list is traversed in multiple places. The overhead
should be negligible in comparison to a rewrite and the list should not contain
a lot of rewrites in practice.

The pending_rewrites list is traversed in multiple places. In typical usage,
the list will contain only a few entries so the traversal cost is negligible (
furthermore in comparison to a rewrite).
---
 src/backend/catalog/index.c                  |   2 +-
 src/backend/commands/cluster.c               |   5 +
 src/backend/commands/tablecmds.c             |   6 +
 src/backend/utils/activity/pgstat_relation.c | 391 ++++++++++++++++++-
 src/backend/utils/activity/pgstat_xact.c     |  25 +-
 src/backend/utils/cache/relcache.c           |   6 +
 src/include/pgstat.h                         |   5 +-
 src/tools/pgindent/typedefs.list             |   1 +
 8 files changed, 424 insertions(+), 17 deletions(-)
  92.8% src/backend/utils/activity/
   4.9% src/backend/

diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index d8219b18c48..079e504b96f 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -1796,7 +1796,7 @@ index_concurrently_swap(Oid newIndexId, Oid oldIndexId, const char *oldName)
 	changeDependenciesOn(RelationRelationId, oldIndexId, newIndexId);
 
 	/* copy over statistics from old to new index */
-	pgstat_copy_relation_stats(newClassRel, oldClassRel);
+	pgstat_copy_relation_stats(newClassRel->rd_locator, oldClassRel->rd_locator, false);
 
 	/* Copy data of pg_statistic from the old index to the new one */
 	CopyStatistics(oldIndexId, newIndexId);
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/cluster.c
index 09066db0956..c491daceb0f 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/cluster.c
@@ -1206,6 +1206,11 @@ swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class,
 
 		rel1 = relation_open(r1, NoLock);
 		rel2 = relation_open(r2, NoLock);
+
+		/* Mark that a rewrite happened */
+		if (RELKIND_HAS_STORAGE(rel1->rd_rel->relkind))
+			pgstat_mark_rewrite(rel1->rd_locator, rel2->rd_locator);
+
 		rel2->rd_createSubid = rel1->rd_createSubid;
 		rel2->rd_newRelfilelocatorSubid = rel1->rd_newRelfilelocatorSubid;
 		rel2->rd_firstRelfilelocatorSubid = rel1->rd_firstRelfilelocatorSubid;
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index c69c12dc014..13630846116 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -17099,6 +17099,7 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 	Oid			reltoastrelid;
 	RelFileNumber newrelfilenumber;
 	RelFileLocator newrlocator;
+	RelFileLocator oldrlocator;
 	List	   *reltoastidxids = NIL;
 	ListCell   *lc;
 
@@ -17137,6 +17138,7 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 	newrlocator = rel->rd_locator;
 	newrlocator.relNumber = newrelfilenumber;
 	newrlocator.spcOid = newTableSpace;
+	oldrlocator = rel->rd_locator;
 
 	/* hand off to AM to actually create new rel storage and copy the data */
 	if (rel->rd_rel->relkind == RELKIND_INDEX)
@@ -17149,6 +17151,10 @@ ATExecSetTableSpace(Oid tableOid, Oid newTableSpace, LOCKMODE lockmode)
 		table_relation_copy_data(rel, &newrlocator);
 	}
 
+	/* mark that a rewrite happened */
+	if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
+		pgstat_mark_rewrite(oldrlocator, newrlocator);
+
 	/*
 	 * Update the pg_class row.
 	 *
diff --git a/src/backend/utils/activity/pgstat_relation.c b/src/backend/utils/activity/pgstat_relation.c
index 89bf0cbed56..4d929972fab 100644
--- a/src/backend/utils/activity/pgstat_relation.c
+++ b/src/backend/utils/activity/pgstat_relation.c
@@ -30,6 +30,19 @@
 #include "utils/syscache.h"
 #include "utils/timestamp.h"
 
+/* Pending rewrite operations for stats copying */
+typedef struct PgStat_PendingRewrite
+{
+	RelFileLocator old_locator;
+	RelFileLocator new_locator;
+	RelFileLocator original_locator;
+	int			nest_level;		/* Transaction nesting level where rewrite
+								 * occurred */
+	struct PgStat_PendingRewrite *next;
+} PgStat_PendingRewrite;
+
+/* The pending rewrites list for current transaction */
+static PgStat_PendingRewrite *pending_rewrites = NULL;
 
 /* Record that's written to 2PC state file when pgstat state is persisted */
 typedef struct TwoPhasePgStatRecord
@@ -43,6 +56,8 @@ typedef struct TwoPhasePgStatRecord
 	PgStat_Counter deleted_pre_truncdrop;
 	RelFileLocator locator;		/* table's rd_locator */
 	bool		truncdropped;	/* was the relation truncated/dropped? */
+	RelFileLocator rewrite_old_locator;
+	int			rewrite_nest_level;
 } TwoPhasePgStatRecord;
 
 
@@ -54,27 +69,70 @@ static void restore_truncdrop_counters(PgStat_TableXactStatus *trans);
 
 
 /*
- * Copy stats between relations. This is used for things like REINDEX
+ * Copy stats between RelFileLocator. This is used for things like REINDEX
  * CONCURRENTLY.
  */
 void
-pgstat_copy_relation_stats(Relation dst, Relation src)
+pgstat_copy_relation_stats(RelFileLocator dst, RelFileLocator src, bool increment)
 {
 	PgStat_StatTabEntry *srcstats;
 	PgStatShared_Relation *dstshstats;
 	PgStat_EntryRef *dst_ref;
 
-	srcstats = pgstat_fetch_stat_tabentry_ext(RelationGetRelid(src));
+	srcstats = (PgStat_StatTabEntry *) pgstat_fetch_entry(PGSTAT_KIND_RELATION,
+														  src.dbOid,
+														  RelFileLocatorToPgStatObjid(src));
 	if (!srcstats)
 		return;
 
 	dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
-										  dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
-										  RelationGetRelid(dst),
+										  dst.dbOid,
+										  RelFileLocatorToPgStatObjid(dst),
 										  false);
 
 	dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
-	dstshstats->stats = *srcstats;
+
+	if (!increment)
+		dstshstats->stats = *srcstats;
+	else
+	{
+		/* Increment those statistics */
+#define RELFSTAT_ACC(fld, stats_to_add) \
+	(dstshstats->stats.fld += stats_to_add->fld)
+		RELFSTAT_ACC(numscans, srcstats);
+		RELFSTAT_ACC(tuples_returned, srcstats);
+		RELFSTAT_ACC(tuples_fetched, srcstats);
+		RELFSTAT_ACC(tuples_inserted, srcstats);
+		RELFSTAT_ACC(tuples_updated, srcstats);
+		RELFSTAT_ACC(tuples_deleted, srcstats);
+		RELFSTAT_ACC(tuples_hot_updated, srcstats);
+		RELFSTAT_ACC(tuples_newpage_updated, srcstats);
+		RELFSTAT_ACC(live_tuples, srcstats);
+		RELFSTAT_ACC(dead_tuples, srcstats);
+		RELFSTAT_ACC(mod_since_analyze, srcstats);
+		RELFSTAT_ACC(ins_since_vacuum, srcstats);
+		RELFSTAT_ACC(blocks_fetched, srcstats);
+		RELFSTAT_ACC(blocks_hit, srcstats);
+		RELFSTAT_ACC(vacuum_count, srcstats);
+		RELFSTAT_ACC(autovacuum_count, srcstats);
+		RELFSTAT_ACC(analyze_count, srcstats);
+		RELFSTAT_ACC(autoanalyze_count, srcstats);
+		RELFSTAT_ACC(total_vacuum_time, srcstats);
+		RELFSTAT_ACC(total_autovacuum_time, srcstats);
+		RELFSTAT_ACC(total_analyze_time, srcstats);
+		RELFSTAT_ACC(total_autoanalyze_time, srcstats);
+#undef RELFSTAT_ACC
+
+		/* Replace those statistics */
+#define RELFSTAT_REP(fld, stats_to_rep) \
+	(dstshstats->stats.fld = stats_to_rep->fld)
+		RELFSTAT_REP(lastscan, srcstats);
+		RELFSTAT_REP(last_vacuum_time, srcstats);
+		RELFSTAT_REP(last_autovacuum_time, srcstats);
+		RELFSTAT_REP(last_analyze_time, srcstats);
+		RELFSTAT_REP(last_autoanalyze_time, srcstats);
+#undef RELFSTAT_REP
+	}
 
 	pgstat_unlock_entry(dst_ref);
 }
@@ -136,6 +194,7 @@ void
 pgstat_assoc_relation(Relation rel)
 {
 	RelFileLocator locator;
+	PgStat_TableStatus *pgstat_info;
 
 	Assert(rel->pgstat_enabled);
 	Assert(rel->pgstat_info == NULL);
@@ -164,14 +223,54 @@ pgstat_assoc_relation(Relation rel)
 		locator.relNumber = rel->rd_id;
 	}
 
+	/*
+	 * If this relation was rewritten during the current transaction we may be
+	 * reopening it with its new RelFileLocator. In that case, continue using
+	 * the stats entry associated with the old locator rather than creating a
+	 * new one. This ensures all stats from before and after the rewrite are
+	 * tracked in a single entry which will be properly copied to the new
+	 * locator at transaction commit.
+	 */
+	if (pending_rewrites != NULL)
+	{
+		PgStat_PendingRewrite *rewrite;
+
+		for (rewrite = pending_rewrites; rewrite != NULL; rewrite = rewrite->next)
+		{
+			if (locator.dbOid == rewrite->new_locator.dbOid &&
+				locator.spcOid == rewrite->new_locator.spcOid &&
+				locator.relNumber == rewrite->new_locator.relNumber)
+			{
+				pgstat_info = pgstat_prep_relation_pending(rewrite->old_locator);
+				goto found_entry;
+			}
+		}
+	}
+
 	/* Else find or make the PgStat_TableStatus entry, and update link */
-	rel->pgstat_info = pgstat_prep_relation_pending(locator);
+	pgstat_info = pgstat_prep_relation_pending(locator);
+
+found_entry:
+	rel->pgstat_info = pgstat_info;
+
+	/*
+	 * For relations stats, we key by physical file location, not by relation
+	 * OID. This means during operations like ALTER TYPE it's possible that
+	 * the relation OID changes but the relfilenode stays the same (no actual
+	 * rewrite needed). Unlink the old relation first.
+	 */
+	if (pgstat_info->relation != NULL &&
+		pgstat_info->relation != rel)
+	{
+		pgstat_info->relation->pgstat_info = NULL;
+		pgstat_info->relation = NULL;
+	}
 
 	/* don't allow link a stats to multiple relcache entries */
-	Assert(rel->pgstat_info->relation == NULL);
+	Assert(pgstat_info->relation == NULL);
 
 	/* mark this relation as the owner */
-	rel->pgstat_info->relation = rel;
+	pgstat_info->relation = rel;
 }
 
 /*
@@ -214,14 +313,37 @@ pgstat_drop_relation(Relation rel)
 {
 	int			nest_level = GetCurrentTransactionNestLevel();
 	PgStat_TableStatus *pgstat_info;
+	bool		skip_transactional_drop = false;
 
 	/* don't track stats for relations without storage */
 	if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
 		return;
 
-	pgstat_drop_transactional(PGSTAT_KIND_RELATION,
-							  rel->rd_locator.dbOid,
-							  RelFileLocatorToPgStatObjid(rel->rd_locator));
+	/* Check if this drop is part of a pending rewrite */
+	if (pending_rewrites != NULL)
+	{
+		PgStat_PendingRewrite *rewrite;
+
+		for (rewrite = pending_rewrites; rewrite != NULL; rewrite = rewrite->next)
+		{
+			if (rel->rd_locator.dbOid == rewrite->old_locator.dbOid &&
+				rel->rd_locator.spcOid == rewrite->old_locator.spcOid &&
+				rel->rd_locator.relNumber == rewrite->old_locator.relNumber)
+			{
+				skip_transactional_drop = true;
+				break;
+			}
+		}
+	}
+
+	/*
+	 * If it is part of a rewrite, drop its stats later, for example in
+	 * AtEOXact_PgStat_Relations(), so skip it here.
+	 */
+	if (!skip_transactional_drop)
+		pgstat_drop_transactional(PGSTAT_KIND_RELATION,
+								  rel->rd_locator.dbOid,
+								  RelFileLocatorToPgStatObjid(rel->rd_locator));
 
 	if (!pgstat_should_count_relation(rel))
 		return;
@@ -666,6 +788,48 @@ AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit)
 		}
 		tabstat->trans = NULL;
 	}
+
+	/* preserve the stats in case of rewrite */
+	if (isCommit && pending_rewrites != NULL)
+	{
+		PgStat_PendingRewrite *rewrite;
+		PgStat_PendingRewrite *prev = NULL;
+		PgStat_PendingRewrite *current = pending_rewrites;
+		PgStat_PendingRewrite *next;
+
+		/* reverse the rewrites list to process in chronological order */
+		while (current != NULL)
+		{
+			next = current->next;
+			current->next = prev;
+			prev = current;
+			current = next;
+		}
+
+		/* now process rewrites in chronological order */
+		for (rewrite = prev; rewrite != NULL; rewrite = rewrite->next)
+		{
+			PgStat_EntryRef *old_entry_ref;
+
+			old_entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION,
+													   rewrite->old_locator.dbOid,
+													   RelFileLocatorToPgStatObjid(rewrite->old_locator));
+
+			if (old_entry_ref && old_entry_ref->pending)
+				pgstat_relation_flush_cb(old_entry_ref, false);
+
+			pgstat_copy_relation_stats(rewrite->new_locator,
+									   rewrite->old_locator, true);
+
+			/* drop old locator's stats */
+			if (!pgstat_drop_entry(PGSTAT_KIND_RELATION,
+								   rewrite->old_locator.dbOid,
+								   RelFileLocatorToPgStatObjid(rewrite->old_locator)))
+				pgstat_request_entry_refs_gc();
+		}
+	}
+
+	pending_rewrites = NULL;
 }
 
 /*
@@ -681,6 +845,30 @@ AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, in
 	PgStat_TableXactStatus *trans;
 	PgStat_TableXactStatus *next_trans;
 
+	/*
+	 * If we don't commit then remove the associated rewrites if any, to keep
+	 * the rewrite chain in sync with what will be eventually committed.
+	 */
+	if (!isCommit)
+	{
+		PgStat_PendingRewrite **rewrite_ptr = &pending_rewrites;
+
+		while (*rewrite_ptr != NULL)
+		{
+			if ((*rewrite_ptr)->nest_level >= nestDepth)
+			{
+				PgStat_PendingRewrite *to_remove = *rewrite_ptr;
+
+				*rewrite_ptr = (*rewrite_ptr)->next;
+				pfree(to_remove);
+			}
+			else
+			{
+				rewrite_ptr = &((*rewrite_ptr)->next);
+			}
+		}
+	}
+
 	for (trans = xact_state->first; trans != NULL; trans = next_trans)
 	{
 		PgStat_TableStatus *tabstat;
@@ -760,11 +948,19 @@ void
 AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
 {
 	PgStat_TableXactStatus *trans;
+	PgStat_PendingRewrite *rewrite;
 
+	/*
+	 * For each tabstat, find its matching rewrite and remove it from the
+	 * pending rewrites list. This way, after processing all tabstats, pending
+	 * rewrites will only contain rewrite only transactions.
+	 */
 	for (trans = xact_state->first; trans != NULL; trans = trans->next)
 	{
 		PgStat_TableStatus *tabstat PG_USED_FOR_ASSERTS_ONLY;
 		TwoPhasePgStatRecord record;
+		PgStat_PendingRewrite **rewrite_ptr;
+		bool		found_rewrite = false;
 
 		Assert(trans->nest_level == 1);
 		Assert(trans->upper == NULL);
@@ -784,10 +980,83 @@ AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
 			record.locator = tabstat->locator;
 
 		record.truncdropped = trans->truncdropped;
+		record.rewrite_nest_level = 0;
+
+		/*
+		 * Look for a matching rewrite and remove it from pending rewrites. We
+		 * check three possible matches:
+		 *
+		 * The new_locator when stats have been added after the rewrite. The
+		 * old_locator when stats have been added before the rewrite but not
+		 * after. The original_locator when this tabstat is part of a rewrite
+		 * chain.
+		 */
+		rewrite_ptr = &pending_rewrites;
+		while (*rewrite_ptr != NULL)
+		{
+			rewrite = *rewrite_ptr;
+
+			if ((record.locator.dbOid == rewrite->new_locator.dbOid &&
+				 record.locator.spcOid == rewrite->new_locator.spcOid &&
+				 record.locator.relNumber == rewrite->new_locator.relNumber) ||
+				(tabstat->locator.dbOid == rewrite->old_locator.dbOid &&
+				 tabstat->locator.spcOid == rewrite->old_locator.spcOid &&
+				 tabstat->locator.relNumber == rewrite->old_locator.relNumber) ||
+				(tabstat->locator.dbOid == rewrite->original_locator.dbOid &&
+				 tabstat->locator.spcOid == rewrite->original_locator.spcOid &&
+				 tabstat->locator.relNumber == rewrite->original_locator.relNumber))
+			{
+				/*
+				 * Found matching rewrite. Record the rewrite information and
+				 * remove this rewrite from the list since it's now handled.
+				 */
+				record.rewrite_old_locator = rewrite->original_locator;
+				record.rewrite_nest_level = rewrite->nest_level;
+				record.locator = rewrite->new_locator;
+				found_rewrite = true;
+
+				/* Remove from pending_rewrites list */
+				*rewrite_ptr = rewrite->next;
+				pfree(rewrite);
+				break;
+			}
+			else
+			{
+				/* Move to next rewrite in the list */
+				rewrite_ptr = &(rewrite->next);
+			}
+		}
+
+		/* If no rewrite found, clear the rewrite fields */
+		if (!found_rewrite)
+		{
+			memset(&record.rewrite_old_locator, 0, sizeof(RelFileLocator));
+		}
+
+		RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
+							   &record, sizeof(TwoPhasePgStatRecord));
+	}
+
+	/*
+	 * Now process any rewrites still pending. These are rewrite only
+	 * transactions. We need to preserve their stats even though there's no
+	 * tabstat entry for them.
+	 */
+	for (rewrite = pending_rewrites; rewrite != NULL; rewrite = rewrite->next)
+	{
+		TwoPhasePgStatRecord record;
+
+		memset(&record, 0, sizeof(TwoPhasePgStatRecord));
+		record.locator = rewrite->new_locator;
+		record.rewrite_old_locator = rewrite->original_locator;
+		record.rewrite_nest_level = rewrite->nest_level;
+		record.truncdropped = false;
 
 		RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
 							   &record, sizeof(TwoPhasePgStatRecord));
 	}
+
+	pending_rewrites = NULL;
 }
 
 /*
@@ -810,6 +1079,8 @@ PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)
 		tabstat = trans->parent;
 		tabstat->trans = NULL;
 	}
+
+	pending_rewrites = NULL;
 }
 
 /*
@@ -845,6 +1116,29 @@ pgstat_twophase_postcommit(FullTransactionId fxid, uint16 info,
 	pgstat_info->counts.changed_tuples +=
 		rec->tuples_inserted + rec->tuples_updated +
 		rec->tuples_deleted;
+
+	if (rec->rewrite_nest_level > 0)
+	{
+		PgStat_EntryRef *old_entry_ref;
+
+		/* Flush any pending stats for old locator first */
+		old_entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION,
+												   rec->rewrite_old_locator.dbOid,
+												   RelFileLocatorToPgStatObjid(rec->rewrite_old_locator));
+
+		if (old_entry_ref && old_entry_ref->pending)
+			pgstat_relation_flush_cb(old_entry_ref, false);
+
+		/* Copy stats from old to new locator */
+		pgstat_copy_relation_stats(rec->locator, rec->rewrite_old_locator,
+								   true);
+
+		/* Drop old locator's stats */
+		if (!pgstat_drop_entry(PGSTAT_KIND_RELATION,
+							   rec->rewrite_old_locator.dbOid,
+							   RelFileLocatorToPgStatObjid(rec->rewrite_old_locator)))
+			pgstat_request_entry_refs_gc();
+	}
 }
 
 /*
@@ -859,9 +1153,26 @@ pgstat_twophase_postabort(FullTransactionId fxid, uint16 info,
 {
 	TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
 	PgStat_TableStatus *pgstat_info;
+	RelFileLocator target_locator;
+
+	/*
+	 * For aborted transactions with rewrites (like TRUNCATE), we need to
+	 * restore stats to the old locator, not the new one. The new locator
+	 * should be dropped since the rewrite is being rolled back.
+	 */
+	if (rec->rewrite_nest_level > 0)
+	{
+		/* Use the old locator */
+		target_locator = rec->rewrite_old_locator;
+	}
+	else
+	{
+		/* No rewrite, use the original locator */
+		target_locator = rec->locator;
+	}
 
 	/* Find or create a tabstat entry for the target locator */
-	pgstat_info = pgstat_prep_relation_pending(rec->locator);
+	pgstat_info = pgstat_prep_relation_pending(target_locator);
 
 	/* Same math as in AtEOXact_PgStat, abort case */
 	if (rec->truncdropped)
@@ -916,7 +1227,17 @@ pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait)
 	tabentry->numscans += lstats->counts.numscans;
 	if (lstats->counts.numscans)
 	{
-		TimestampTz t = GetCurrentTransactionStopTimestamp();
+		TimestampTz t;
+
+		/*
+		 * Checking the transaction state due to the flush call in
+		 * pgstat_twophase_postcommit() that would break the assertion on the
+		 * state in GetCurrentTransactionStopTimestamp().
+		 */
+		if (!IsTransactionState())
+			t = GetCurrentTransactionStopTimestamp();
+		else
+			t = GetCurrentTimestamp();
 
 		if (t > tabentry->lastscan)
 			tabentry->lastscan = t;
@@ -1167,3 +1488,45 @@ pgstat_reloid_to_relfilelocator(Oid reloid, RelFileLocator *locator)
 	ReleaseSysCache(tuple);
 	return result;
 }
+
+/*
+ * Mark that a relation rewrite has occurred, preserving the original locator
+ * so stats can be copied at transaction commit.
+ */
+void
+pgstat_mark_rewrite(RelFileLocator old_locator, RelFileLocator new_locator)
+{
+	PgStat_PendingRewrite *rewrite;
+	PgStat_PendingRewrite *existing;
+	RelFileLocator original_locator = old_locator;
+
+	for (existing = pending_rewrites; existing != NULL; existing = existing->next)
+	{
+		if (old_locator.dbOid == existing->new_locator.dbOid &&
+			old_locator.spcOid == existing->new_locator.spcOid &&
+			old_locator.relNumber == existing->new_locator.relNumber)
+		{
+			original_locator = existing->original_locator;
+			break;
+		}
+	}
+
+	/* Allocate in TopTransactionContext memory context */
+	rewrite = MemoryContextAlloc(TopTransactionContext,
+								 sizeof(PgStat_PendingRewrite));
+
+	rewrite->old_locator = old_locator;
+	rewrite->new_locator = new_locator;
+	rewrite->original_locator = original_locator;
+	rewrite->nest_level = GetCurrentTransactionNestLevel();
+
+	/* Add to the list */
+	rewrite->next = pending_rewrites;
+	pending_rewrites = rewrite;
+}
+
+void
+pgstat_clear_rewrite(void)
+{
+	pending_rewrites = NULL;
+}
diff --git a/src/backend/utils/activity/pgstat_xact.c b/src/backend/utils/activity/pgstat_xact.c
index 5e2d69e6297..8ed8f5317f3 100644
--- a/src/backend/utils/activity/pgstat_xact.c
+++ b/src/backend/utils/activity/pgstat_xact.c
@@ -55,6 +55,8 @@ AtEOXact_PgStat(bool isCommit, bool parallel)
 	}
 	pgStatXactStack = NULL;
 
+	pgstat_clear_rewrite();
+
 	/* Make sure any stats snapshot is thrown away */
 	pgstat_clear_snapshot();
 }
@@ -360,8 +362,29 @@ create_drop_transactional_internal(PgStat_Kind kind, Oid dboid, uint64 objid, bo
 void
 pgstat_create_transactional(PgStat_Kind kind, Oid dboid, uint64 objid)
 {
-	if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL))
+	PgStat_EntryRef *entry_ref;
+
+	entry_ref = pgstat_get_entry_ref(kind, dboid, objid, false, NULL);
+
+	if (entry_ref)
 	{
+		/*
+		 * For relations stats, we key by physical file location, not by
+		 * relation OID. This means during operations like ALTER TYPE where
+		 * the relation OID changes but the relfilenode stays the same (no
+		 * actual rewrite needed), we'll find an existing entry.
+		 *
+		 * This is expected behavior, we want to preserve stats across the
+		 * catalog change. Simply reset and recreate the entry for the new
+		 * relation OID without warning.
+		 */
+		if (kind == PGSTAT_KIND_RELATION)
+		{
+			pgstat_reset(kind, dboid, objid);
+			create_drop_transactional_internal(kind, dboid, objid, true);
+			return;
+		}
+
 		ereport(WARNING,
 				errmsg("resetting existing statistics for kind %s, db=%u, oid=%" PRIu64,
 					   (pgstat_get_kind_info(kind))->name, dboid,
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index e19f0d3e51c..bf49830dba2 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -87,6 +87,7 @@
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/pgstat_internal.h"
 #include "utils/relmapper.h"
 #include "utils/resowner.h"
 #include "utils/snapmgr.h"
@@ -3772,6 +3773,7 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 	MultiXactId minmulti = InvalidMultiXactId;
 	TransactionId freezeXid = InvalidTransactionId;
 	RelFileLocator newrlocator;
+	RelFileLocator oldrlocator = relation->rd_locator;
 
 	if (!IsBinaryUpgrade)
 	{
@@ -3943,6 +3945,10 @@ RelationSetNewRelfilenumber(Relation relation, char persistence)
 
 	table_close(pg_class, RowExclusiveLock);
 
+	/* Mark that a rewrite happened */
+	if (RELKIND_HAS_STORAGE(relation->rd_rel->relkind))
+		pgstat_mark_rewrite(oldrlocator, newrlocator);
+
 	/*
 	 * Make the pg_class row change or relation map change visible.  This will
 	 * cause the relcache entry to get updated, too.
diff --git a/src/include/pgstat.h b/src/include/pgstat.h
index ef740aff26e..4d3130ae99e 100644
--- a/src/include/pgstat.h
+++ b/src/include/pgstat.h
@@ -701,7 +701,7 @@ extern PgStat_FunctionCounts *find_funcstat_entry(Oid func_id);
 
 extern void pgstat_create_relation(Relation rel);
 extern void pgstat_drop_relation(Relation rel);
-extern void pgstat_copy_relation_stats(Relation dst, Relation src);
+extern void pgstat_copy_relation_stats(RelFileLocator dst, RelFileLocator src, bool increment);
 
 extern void pgstat_init_relation(Relation rel);
 extern void pgstat_assoc_relation(Relation rel);
@@ -713,6 +713,9 @@ extern void pgstat_report_vacuum(Relation rel, PgStat_Counter livetuples,
 extern void pgstat_report_analyze(Relation rel,
 								  PgStat_Counter livetuples, PgStat_Counter deadtuples,
 								  bool resetcounter, TimestampTz starttime);
+extern void pgstat_mark_rewrite(RelFileLocator old_locator,
+								RelFileLocator new_locator);
+extern void pgstat_clear_rewrite(void);
 
 /*
  * If stats are enabled, but pending data hasn't been prepared yet, call
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index dbbec84b222..bae04e95989 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2310,6 +2310,7 @@ PgStat_LockEntry
 PgStat_PendingDroppedStatsItem
 PgStat_PendingIO
 PgStat_PendingLock
+PgStat_PendingRewrite
 PgStat_SLRUStats
 PgStat_ShmemControl
 PgStat_Snapshot
-- 
2.34.1


--96iU9DKeu+W+YlSa--





^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread

* [PATCH v2 3/4] Optimize more data type for less memory copy with optional context.
@ 2026-06-02 09:37  Andy Fan <zhihuifan1213@163.com>
  0 siblings, 0 replies; 513+ messages in thread

From: Andy Fan @ 2026-06-02 09:37 UTC (permalink / raw)

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


--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
 filename=v2-0004-Let-pgbench-support-binary-format.patch



^ permalink  raw  reply  [nested|flat] 513+ messages in thread