Cache TupleDesc per composite column in copy_dest_receive

For INSERT..SELECT involving composite-type columns, each row called
lookup_rowtype_tupdesc (via StructOutForPGDuck) triggering the expensive
insert_rel_type_cache_if_needed path on every row.

Add a composite_tupdescs cache array (one slot per physical attribute) to
CopyToStateData.  In CopyOneRowTo, validate and reuse the cached TupleDesc
for composite columns, falling back to lookup_rowtype_tupdesc only on the
first row or a type change.  The pin is held for the duration of the COPY
and released in EndCopy.

PGDuckSerialize and StructOutForPGDuck gain a cachedTupleDesc parameter;
when non-NULL the tupdesc is used directly, skipping both the lookup and
the matching ReleaseTupleDesc.  All other call sites pass NULL.

Signed-off-by: David Christensen <david.christensen@snowflake.com>

Author: sfc-gh-dachristensen

pg_lake_engine/include/pg_lake/pgduck/array_conversion.h

@@ -17,9 +17,11 @@
 
 #pragma once
 
+#include "access/tupdesc.h"
 #include "utils/array.h"
 #include "pg_lake/copy/copy_format.h"
 
 #define ARRAY_OUT_OID (751)
 
-extern PGDLLEXPORT char *ArrayOutForPGDuck(ArrayType *array, CopyDataFormat format);
+extern PGDLLEXPORT char *ArrayOutForPGDuck(ArrayType *array, CopyDataFormat format,
+										   TupleDesc cachedElemTupleDesc);

pg_lake_engine/include/pg_lake/pgduck/serialize.h

@@ -20,13 +20,14 @@
 #include "postgres.h"
 #include "fmgr.h"
 
+#include "access/tupdesc.h"
 #include "pg_lake/parquet/field.h"
 #include "pg_lake/pgduck/type.h"
 
 #define BYTEA_OUT_OID 31
 
 extern PGDLLEXPORT char *PGDuckSerialize(FmgrInfo *flinfo, Oid typeOid, Datum value,
-										 CopyDataFormat format);
+										 CopyDataFormat format, TupleDesc cachedTupleDesc);
 extern PGDLLEXPORT char *PGDuckOnlySerialize(Oid typeOid, Datum value);
 extern PGDLLEXPORT bool IsPGDuckSerializeRequired(PGType postgresType);
 extern PGDLLEXPORT char *IntervalOutForPGDuck(Datum value);

pg_lake_engine/include/pg_lake/pgduck/struct_conversion.h

@@ -17,8 +17,10 @@
 
 #pragma once
 
+#include "access/tupdesc.h"
 #include "pg_lake/copy/copy_format.h"
 
 #define RECORD_OUT_OID 2291
 
-extern PGDLLEXPORT char *StructOutForPGDuck(Datum myStruct, CopyDataFormat format);
+extern PGDLLEXPORT char *StructOutForPGDuck(Datum myStruct, CopyDataFormat format,
+											TupleDesc cachedTupleDesc);

pg_lake_engine/src/csv/csv_writer.c

@@ -29,6 +29,8 @@
 #include "fmgr.h"
 #include "miscadmin.h"
 
+#include "access/htup_details.h"
+#include "catalog/pg_type.h"
 #include "catalog/pg_type_d.h"
 #include "commands/copy.h"
 #include "commands/defrem.h"
@@ -45,6 +47,7 @@
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/typcache.h"
 #include "utils/numeric.h"
 #include "utils/rel.h"
 
@@ -101,6 +104,13 @@ typedef struct CopyToStateData
 	MemoryContext copycontext;	/* per-copy execution context */
 
 	FmgrInfo   *out_functions;	/* lookup info for output functions */
+
+	/*
+	 * Per-column TupleDesc cache for composite-type columns.  NULL means the
+	 * column is not composite (or is an anonymous RECORD column).  A non-NULL
+	 * value is a pinned TupleDesc looked up once during StartCopyTo.
+	 */
+	TupleDesc  *composite_tupdescs;
 	MemoryContext rowcontext;	/* per-row evaluation context */
 	uint64		bytes_processed;	/* number of bytes processed so far */
 
@@ -287,6 +297,20 @@ EndCopy(CopyToState cstate)
 		}
 	}
 
+	/* Release pinned TupleDescs from the composite type cache */
+	{
+		ListCell   *cur;
+
+		foreach(cur, cstate->attnumlist)
+		{
+			int			attnum = lfirst_int(cur);
+			TupleDesc	cached = cstate->composite_tupdescs[attnum - 1];
+
+			if (cached != NULL)
+				ReleaseTupleDesc(cached);
+		}
+	}
+
 	MemoryContextDelete(cstate->rowcontext);
 	MemoryContextDelete(cstate->copycontext);
 }
@@ -453,6 +477,7 @@ StartCopyTo(CopyToState cstate, TupleDesc tupDesc)
 
 	/* Get info about the columns we need to process. */
 	cstate->out_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
+	cstate->composite_tupdescs = (TupleDesc *) palloc0(num_phys_attrs * sizeof(TupleDesc));
 	foreach(cur, cstate->attnumlist)
 	{
 		int			attnum = lfirst_int(cur);
@@ -469,6 +494,22 @@ StartCopyTo(CopyToState cstate, TupleDesc tupDesc)
 							  &out_func_oid,
 							  &isvarlena);
 		fmgr_info(out_func_oid, &cstate->out_functions[attnum - 1]);
+
+		/*
+		 * Pre-populate the TupleDesc cache for composite columns and
+		 * arrays of composite elements.  Anonymous RECORD types are skipped
+		 * because their structure is not known until row data is inspected.
+		 */
+		{
+			Oid			elemTypeOid = get_element_type(attr->atttypid);
+			Oid			baseTypeOid = OidIsValid(elemTypeOid) ? elemTypeOid : attr->atttypid;
+			int32		baseTypmod = OidIsValid(elemTypeOid) ? -1 : attr->atttypmod;
+
+			if (get_typtype(baseTypeOid) == TYPTYPE_COMPOSITE &&
+				baseTypeOid != RECORDOID)
+				cstate->composite_tupdescs[attnum - 1] =
+					lookup_rowtype_tupdesc(baseTypeOid, baseTypmod);
+		}
 	}
 
 	/*
@@ -775,12 +816,25 @@ CopyOneRowTo(CopyToState cstate, TupleTableSlot *slot)
 					 * Since we are at the top-level when emitting an
 					 * attribute in CopyOneRowTo(), we are not inside a
 					 * composite type.
+					 *
+					 * For composite-type columns, cache the TupleDesc so
+					 * we avoid repeating the expensive lookup_rowtype_tupdesc
+					 * call on every row.
+					 */
+					/*
+					 * Pass the pre-populated TupleDesc (non-NULL for
+					 * composite columns and arrays of composite elements)
+					 * so PGDuckSerialize can skip the per-row
+					 * lookup_rowtype_tupdesc call.
 					 */
+					TupleDesc	cachedTupleDesc =
+						cstate->composite_tupdescs[attnum - 1];
 
 					string = PGDuckSerialize(&out_functions[attnum - 1],
 											 attr->atttypid,
 											 value,
-											 cstate->targetFormat);
+											 cstate->targetFormat,
+											 cachedTupleDesc);
 				}
 				else
 					string = OutputFunctionCall(&out_functions[attnum - 1],

pg_lake_engine/src/data_file/data_file_stats.c

@@ -772,7 +772,7 @@ SerializeTextArrayTypeToPgDuck(ArrayType *array)
 	getTypeOutputInfo(TEXTARRAYOID, &outFuncId, &isvarlena);
 	fmgr_info(outFuncId, &outFunc);
 
-	return PGDuckSerialize(&outFunc, TEXTARRAYOID, arrayDatum, DATA_FORMAT_INVALID);
+	return PGDuckSerialize(&outFunc, TEXTARRAYOID, arrayDatum, DATA_FORMAT_INVALID, NULL);
 }
 
 

pg_lake_engine/src/pgduck/array_conversion.c

@@ -17,6 +17,7 @@
 
 #include "postgres.h"
 
+#include "access/tupdesc.h"
 #include "pg_lake/pgduck/array_conversion.h"
 #include "pg_lake/pgduck/serialize.h"
 #include "utils/arrayaccess.h"
@@ -34,7 +35,8 @@
  * - we do not use fcinfo (not in a UDF) or AnyArrayType
  */
 char *
-ArrayOutForPGDuck(ArrayType *array, CopyDataFormat format)
+ArrayOutForPGDuck(ArrayType *array, CopyDataFormat format,
+				  TupleDesc cachedElemTupleDesc)
 {
 	Oid			element_type = ARR_ELEMTYPE(array);
 	char	   *p,
@@ -113,7 +115,7 @@ ArrayOutForPGDuck(ArrayType *array, CopyDataFormat format)
 		else
 		{
 			values[i] = PGDuckSerialize(&my_extra->proc, element_type, itemvalue,
-										format);
+										format, cachedElemTupleDesc);
 
 			/* count data plus backslashes; detect chars needing quotes */
 			needquote = !IsSerializedAsContainer(element_type, format);

pg_lake_engine/src/pgduck/map_conversion.c

@@ -127,7 +127,7 @@ MapOutForPGDuck(Datum myMap, CopyDataFormat format)
 			ereport(ERROR, (errmsg("cannot have NULL for map key entry")));;
 
 		serializedKey = PGDuckSerialize(&keysExtra->proc, keysElementType, pairValues[0],
-								format);
+								format, NULL);
 		if (!keyIsContainer)
 			serializedKey = (char *) quote_literal_cstr(serializedKey);
 
@@ -136,7 +136,7 @@ MapOutForPGDuck(Datum myMap, CopyDataFormat format)
 		else
 		{
 			serializedValue = PGDuckSerialize(&valuesExtra->proc, valuesElementType, pairValues[1],
-											  format);
+											  format, NULL);
 			if (!valIsContainer)
 				serializedValue = (char *) quote_literal_cstr(serializedValue);
 		}

pg_lake_engine/src/pgduck/rewrite_query.c

@@ -789,7 +789,7 @@ RewriteConst(Const *constExpr)
 
 	/* serialize Const in the DuckDB format */
 	char	   *pgduckText = PGDuckSerialize(&outFunc, constTypeId, constExpr->constvalue,
-											  DATA_FORMAT_INVALID);
+											  DATA_FORMAT_INVALID, NULL);
 
 	/* construct a text constant with the rewritten text */
 	Const	   *textConst = makeNode(Const);

pg_lake_engine/src/pgduck/serialize.c

@@ -125,19 +125,19 @@ ConvertISOYearToBCIfNeeded(const char *dateTimestampString)
  */
 char *
 PGDuckSerialize(FmgrInfo *flinfo, Oid columnType, Datum value,
-				CopyDataFormat format)
+				CopyDataFormat format, TupleDesc cachedTupleDesc)
 {
 	if (flinfo->fn_oid == ARRAY_OUT_OID)
 	{
 		/* maps are a type of array */
 		if (IsMapTypeOid(columnType))
 			return MapOutForPGDuck(value, format);
 
-		return ArrayOutForPGDuck(DatumGetArrayTypeP(value), format);
+		return ArrayOutForPGDuck(DatumGetArrayTypeP(value), format, cachedTupleDesc);
 	}
 
 	if (flinfo->fn_oid == RECORD_OUT_OID)
-		return StructOutForPGDuck(value, format);
+		return StructOutForPGDuck(value, format, cachedTupleDesc);
 
 	/*
 	 * For Iceberg, intervals are serialized as struct(months, days,

pg_lake_engine/src/pgduck/struct_conversion.c

@@ -52,7 +52,7 @@ typedef struct RecordIOData
  */
 
 char *
-StructOutForPGDuck(Datum myStruct, CopyDataFormat format)
+StructOutForPGDuck(Datum myStruct, CopyDataFormat format, TupleDesc cachedTupleDesc)
 {
 	HeapTupleHeader rec = DatumGetHeapTupleHeader(myStruct);
 	Oid			tupType;
@@ -72,7 +72,10 @@ StructOutForPGDuck(Datum myStruct, CopyDataFormat format)
 	/* Extract type info from the tuple itself */
 	tupType = HeapTupleHeaderGetTypeId(rec);
 	tupTypmod = HeapTupleHeaderGetTypMod(rec);
-	tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
+	if (cachedTupleDesc != NULL)
+		tupdesc = cachedTupleDesc;
+	else
+		tupdesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 	ncolumns = tupdesc->natts;
 
 	/* Build a temporary HeapTuple control structure */
@@ -152,7 +155,7 @@ StructOutForPGDuck(Datum myStruct, CopyDataFormat format)
 		}
 
 		attr = values[i];
-		value = PGDuckSerialize(&column_info->proc, column_type, attr, format);
+		value = PGDuckSerialize(&column_info->proc, column_type, attr, format, NULL);
 
 		/* Detect whether we need double quotes for this value */
 		bool		needQuotes = !IsContainerType(column_type);
@@ -176,7 +179,10 @@ StructOutForPGDuck(Datum myStruct, CopyDataFormat format)
 
 	pfree(values);
 	pfree(nulls);
-	ReleaseTupleDesc(tupdesc);
+
+	/* Only release if we looked it up ourselves */
+	if (cachedTupleDesc == NULL)
+		ReleaseTupleDesc(tupdesc);
 
 	return buf.data;
 }