BUG #8573: int4range memory consumption

diff --git a/src/backend/access/common/printtup.c b/src/backend/access/common/printtup.c
index 8daac9e..0e8c947 100644
*** a/src/backend/access/common/printtup.c
--- b/src/backend/access/common/printtup.c
***************
*** 21,26 ****
--- 21,27 ----
  #include "tcop/pquery.h"
  #include "utils/lsyscache.h"
  #include "utils/memdebug.h"
+ #include "utils/memutils.h"
  
  
  static void printtup_startup(DestReceiver *self, int operation,
*************** typedef struct
*** 61,66 ****
--- 62,68 ----
  	TupleDesc	attrinfo;		/* The attr info we are set up for */
  	int			nattrs;
  	PrinttupAttrInfo *myinfo;	/* Cached info about each attr */
+ 	MemoryContext tmpcontext;	/* Memory context for per-row workspace */
  } DR_printtup;
  
  /* ----------------
*************** printtup_create_DR(CommandDest dest)
*** 87,92 ****
--- 89,95 ----
  	self->attrinfo = NULL;
  	self->nattrs = 0;
  	self->myinfo = NULL;
+ 	self->tmpcontext = NULL;
  
  	return (DestReceiver *) self;
  }
*************** printtup_startup(DestReceiver *self, int
*** 124,129 ****
--- 127,144 ----
  	DR_printtup *myState = (DR_printtup *) self;
  	Portal		portal = myState->portal;
  
+ 	/*
+ 	 * Create a temporary memory context that we can reset once per row to
+ 	 * recover palloc'd memory.  This avoids any problems with leaks inside
+ 	 * datatype output routines, and should be faster than retail pfree's
+ 	 * anyway.
+ 	 */
+ 	myState->tmpcontext = AllocSetContextCreate(CurrentMemoryContext,
+ 												"printtup",
+ 												ALLOCSET_DEFAULT_MINSIZE,
+ 												ALLOCSET_DEFAULT_INITSIZE,
+ 												ALLOCSET_DEFAULT_MAXSIZE);
+ 
  	if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
  	{
  		/*
*************** printtup(TupleTableSlot *slot, DestRecei
*** 289,294 ****
--- 304,310 ----
  {
  	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
  	DR_printtup *myState = (DR_printtup *) self;
+ 	MemoryContext oldcontext;
  	StringInfoData buf;
  	int			natts = typeinfo->natts;
  	int			i;
*************** printtup(TupleTableSlot *slot, DestRecei
*** 300,307 ****
  	/* Make sure the tuple is fully deconstructed */
  	slot_getallattrs(slot);
  
  	/*
! 	 * Prepare a DataRow message
  	 */
  	pq_beginmessage(&buf, 'D');
  
--- 316,326 ----
  	/* Make sure the tuple is fully deconstructed */
  	slot_getallattrs(slot);
  
+ 	/* Switch into per-row context so we can recover memory below */
+ 	oldcontext = MemoryContextSwitchTo(myState->tmpcontext);
+ 
  	/*
! 	 * Prepare a DataRow message (note buffer is in per-row context)
  	 */
  	pq_beginmessage(&buf, 'D');
  
*************** printtup(TupleTableSlot *slot, DestRecei
*** 313,320 ****
  	for (i = 0; i < natts; ++i)
  	{
  		PrinttupAttrInfo *thisState = myState->myinfo + i;
! 		Datum		origattr = slot->tts_values[i],
! 					attr;
  
  		if (slot->tts_isnull[i])
  		{
--- 332,338 ----
  	for (i = 0; i < natts; ++i)
  	{
  		PrinttupAttrInfo *thisState = myState->myinfo + i;
! 		Datum		attr = slot->tts_values[i];
  
  		if (slot->tts_isnull[i])
  		{
*************** printtup(TupleTableSlot *slot, DestRecei
*** 323,352 ****
  		}
  
  		/*
! 		 * If we have a toasted datum, forcibly detoast it here to avoid
! 		 * memory leakage inside the type's output routine.
! 		 *
! 		 * Here we catch undefined bytes in tuples that are returned to the
  		 * client without hitting disk; see comments at the related check in
! 		 * PageAddItem().  Whether to test before or after detoast is somewhat
! 		 * arbitrary, as is whether to test external/compressed data at all.
! 		 * Undefined bytes in the pre-toast datum will have triggered Valgrind
! 		 * errors in the compressor or toaster; any error detected here for
! 		 * such datums would indicate an (unlikely) bug in a type-independent
! 		 * facility.  Therefore, this test is most useful for uncompressed,
! 		 * non-external datums.
! 		 *
! 		 * We don't presently bother checking non-varlena datums for undefined
! 		 * data.  PageAddItem() does check them.
  		 */
  		if (thisState->typisvarlena)
! 		{
! 			VALGRIND_CHECK_MEM_IS_DEFINED(origattr, VARSIZE_ANY(origattr));
! 
! 			attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
! 		}
! 		else
! 			attr = origattr;
  
  		if (thisState->format == 0)
  		{
--- 341,355 ----
  		}
  
  		/*
! 		 * Here we catch undefined bytes in datums that are returned to the
  		 * client without hitting disk; see comments at the related check in
! 		 * PageAddItem().  This test is most useful for uncompressed,
! 		 * non-external datums, but we're quite likely to see such here when
! 		 * testing new C functions.
  		 */
  		if (thisState->typisvarlena)
! 			VALGRIND_CHECK_MEM_IS_DEFINED(DatumGetPointer(attr),
! 										  VARSIZE_ANY(attr));
  
  		if (thisState->format == 0)
  		{
*************** printtup(TupleTableSlot *slot, DestRecei
*** 355,361 ****
  
  			outputstr = OutputFunctionCall(&thisState->finfo, attr);
  			pq_sendcountedtext(&buf, outputstr, strlen(outputstr), false);
- 			pfree(outputstr);
  		}
  		else
  		{
--- 358,363 ----
*************** printtup(TupleTableSlot *slot, DestRecei
*** 366,380 ****
  			pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
  			pq_sendbytes(&buf, VARDATA(outputbytes),
  						 VARSIZE(outputbytes) - VARHDRSZ);
- 			pfree(outputbytes);
  		}
- 
- 		/* Clean up detoasted copy, if any */
- 		if (DatumGetPointer(attr) != DatumGetPointer(origattr))
- 			pfree(DatumGetPointer(attr));
  	}
  
  	pq_endmessage(&buf);
  }
  
  /* ----------------
--- 368,381 ----
  			pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
  			pq_sendbytes(&buf, VARDATA(outputbytes),
  						 VARSIZE(outputbytes) - VARHDRSZ);
  		}
  	}
  
  	pq_endmessage(&buf);
+ 
+ 	/* Return to caller's context, and flush row's temporary memory */
+ 	MemoryContextSwitchTo(oldcontext);
+ 	MemoryContextReset(myState->tmpcontext);
  }
  
  /* ----------------
*************** printtup_20(TupleTableSlot *slot, DestRe
*** 386,391 ****
--- 387,393 ----
  {
  	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
  	DR_printtup *myState = (DR_printtup *) self;
+ 	MemoryContext oldcontext;
  	StringInfoData buf;
  	int			natts = typeinfo->natts;
  	int			i,
*************** printtup_20(TupleTableSlot *slot, DestRe
*** 399,404 ****
--- 401,409 ----
  	/* Make sure the tuple is fully deconstructed */
  	slot_getallattrs(slot);
  
+ 	/* Switch into per-row context so we can recover memory below */
+ 	oldcontext = MemoryContextSwitchTo(myState->tmpcontext);
+ 
  	/*
  	 * tell the frontend to expect new tuple data (in ASCII style)
  	 */
*************** printtup_20(TupleTableSlot *slot, DestRe
*** 430,437 ****
  	for (i = 0; i < natts; ++i)
  	{
  		PrinttupAttrInfo *thisState = myState->myinfo + i;
! 		Datum		origattr = slot->tts_values[i],
! 					attr;
  		char	   *outputstr;
  
  		if (slot->tts_isnull[i])
--- 435,441 ----
  	for (i = 0; i < natts; ++i)
  	{
  		PrinttupAttrInfo *thisState = myState->myinfo + i;
! 		Datum		attr = slot->tts_values[i];
  		char	   *outputstr;
  
  		if (slot->tts_isnull[i])
*************** printtup_20(TupleTableSlot *slot, DestRe
*** 439,463 ****
  
  		Assert(thisState->format == 0);
  
- 		/*
- 		 * If we have a toasted datum, forcibly detoast it here to avoid
- 		 * memory leakage inside the type's output routine.
- 		 */
- 		if (thisState->typisvarlena)
- 			attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
- 		else
- 			attr = origattr;
- 
  		outputstr = OutputFunctionCall(&thisState->finfo, attr);
  		pq_sendcountedtext(&buf, outputstr, strlen(outputstr), true);
- 		pfree(outputstr);
- 
- 		/* Clean up detoasted copy, if any */
- 		if (DatumGetPointer(attr) != DatumGetPointer(origattr))
- 			pfree(DatumGetPointer(attr));
  	}
  
  	pq_endmessage(&buf);
  }
  
  /* ----------------
--- 443,457 ----
  
  		Assert(thisState->format == 0);
  
  		outputstr = OutputFunctionCall(&thisState->finfo, attr);
  		pq_sendcountedtext(&buf, outputstr, strlen(outputstr), true);
  	}
  
  	pq_endmessage(&buf);
+ 
+ 	/* Return to caller's context, and flush row's temporary memory */
+ 	MemoryContextSwitchTo(oldcontext);
+ 	MemoryContextReset(myState->tmpcontext);
  }
  
  /* ----------------
*************** printtup_shutdown(DestReceiver *self)
*** 474,479 ****
--- 468,477 ----
  	myState->myinfo = NULL;
  
  	myState->attrinfo = NULL;
+ 
+ 	if (myState->tmpcontext)
+ 		MemoryContextDelete(myState->tmpcontext);
+ 	myState->tmpcontext = NULL;
  }
  
  /* ----------------
*************** debugtup(TupleTableSlot *slot, DestRecei
*** 536,543 ****
  	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
  	int			natts = typeinfo->natts;
  	int			i;
! 	Datum		origattr,
! 				attr;
  	char	   *value;
  	bool		isnull;
  	Oid			typoutput;
--- 534,540 ----
  	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
  	int			natts = typeinfo->natts;
  	int			i;
! 	Datum		attr;
  	char	   *value;
  	bool		isnull;
  	Oid			typoutput;
*************** debugtup(TupleTableSlot *slot, DestRecei
*** 545,574 ****
  
  	for (i = 0; i < natts; ++i)
  	{
! 		origattr = slot_getattr(slot, i + 1, &isnull);
  		if (isnull)
  			continue;
  		getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
  						  &typoutput, &typisvarlena);
  
- 		/*
- 		 * If we have a toasted datum, forcibly detoast it here to avoid
- 		 * memory leakage inside the type's output routine.
- 		 */
- 		if (typisvarlena)
- 			attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
- 		else
- 			attr = origattr;
- 
  		value = OidOutputFunctionCall(typoutput, attr);
  
  		printatt((unsigned) i + 1, typeinfo->attrs[i], value);
- 
- 		pfree(value);
- 
- 		/* Clean up detoasted copy, if any */
- 		if (DatumGetPointer(attr) != DatumGetPointer(origattr))
- 			pfree(DatumGetPointer(attr));
  	}
  	printf("\t----\n");
  }
--- 542,556 ----
  
  	for (i = 0; i < natts; ++i)
  	{
! 		attr = slot_getattr(slot, i + 1, &isnull);
  		if (isnull)
  			continue;
  		getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
  						  &typoutput, &typisvarlena);
  
  		value = OidOutputFunctionCall(typoutput, attr);
  
  		printatt((unsigned) i + 1, typeinfo->attrs[i], value);
  	}
  	printf("\t----\n");
  }
*************** printtup_internal_20(TupleTableSlot *slo
*** 587,592 ****
--- 569,575 ----
  {
  	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
  	DR_printtup *myState = (DR_printtup *) self;
+ 	MemoryContext oldcontext;
  	StringInfoData buf;
  	int			natts = typeinfo->natts;
  	int			i,
*************** printtup_internal_20(TupleTableSlot *slo
*** 600,605 ****
--- 583,591 ----
  	/* Make sure the tuple is fully deconstructed */
  	slot_getallattrs(slot);
  
+ 	/* Switch into per-row context so we can recover memory below */
+ 	oldcontext = MemoryContextSwitchTo(myState->tmpcontext);
+ 
  	/*
  	 * tell the frontend to expect new tuple data (in binary style)
  	 */
*************** printtup_internal_20(TupleTableSlot *slo
*** 631,638 ****
  	for (i = 0; i < natts; ++i)
  	{
  		PrinttupAttrInfo *thisState = myState->myinfo + i;
! 		Datum		origattr = slot->tts_values[i],
! 					attr;
  		bytea	   *outputbytes;
  
  		if (slot->tts_isnull[i])
--- 617,623 ----
  	for (i = 0; i < natts; ++i)
  	{
  		PrinttupAttrInfo *thisState = myState->myinfo + i;
! 		Datum		attr = slot->tts_values[i];
  		bytea	   *outputbytes;
  
  		if (slot->tts_isnull[i])
*************** printtup_internal_20(TupleTableSlot *slo
*** 640,665 ****
  
  		Assert(thisState->format == 1);
  
- 		/*
- 		 * If we have a toasted datum, forcibly detoast it here to avoid
- 		 * memory leakage inside the type's output routine.
- 		 */
- 		if (thisState->typisvarlena)
- 			attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
- 		else
- 			attr = origattr;
- 
  		outputbytes = SendFunctionCall(&thisState->finfo, attr);
- 		/* We assume the result will not have been toasted */
  		pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
  		pq_sendbytes(&buf, VARDATA(outputbytes),
  					 VARSIZE(outputbytes) - VARHDRSZ);
- 		pfree(outputbytes);
- 
- 		/* Clean up detoasted copy, if any */
- 		if (DatumGetPointer(attr) != DatumGetPointer(origattr))
- 			pfree(DatumGetPointer(attr));
  	}
  
  	pq_endmessage(&buf);
  }
--- 625,639 ----
  
  		Assert(thisState->format == 1);
  
  		outputbytes = SendFunctionCall(&thisState->finfo, attr);
  		pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
  		pq_sendbytes(&buf, VARDATA(outputbytes),
  					 VARSIZE(outputbytes) - VARHDRSZ);
  	}
  
  	pq_endmessage(&buf);
+ 
+ 	/* Return to caller's context, and flush row's temporary memory */
+ 	MemoryContextSwitchTo(oldcontext);
+ 	MemoryContextReset(myState->tmpcontext);
  }
diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
index 2a1af63..62f4c18 100644
*** a/src/backend/bootstrap/bootstrap.c
--- b/src/backend/bootstrap/bootstrap.c
*************** InsertOneValue(char *value, int i)
*** 835,841 ****
  	Oid			typioparam;
  	Oid			typinput;
  	Oid			typoutput;
- 	char	   *prt;
  
  	AssertArg(i >= 0 && i < MAXATTR);
  
--- 835,840 ----
*************** InsertOneValue(char *value, int i)
*** 849,857 ****
  						  &typinput, &typoutput);
  
  	values[i] = OidInputFunctionCall(typinput, value, typioparam, -1);
! 	prt = OidOutputFunctionCall(typoutput, values[i]);
! 	elog(DEBUG4, "inserted -> %s", prt);
! 	pfree(prt);
  }
  
  /* ----------------
--- 848,861 ----
  						  &typinput, &typoutput);
  
  	values[i] = OidInputFunctionCall(typinput, value, typioparam, -1);
! 
! 	/*
! 	 * We use ereport not elog here so that parameters aren't evaluated unless
! 	 * the message is going to be printed, which generally it isn't
! 	 */
! 	ereport(DEBUG4,
! 			(errmsg_internal("inserted -> %s",
! 							 OidOutputFunctionCall(typoutput, values[i]))));
  }
  
  /* ----------------
diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
index d91a663..dd35212 100644
*** a/src/backend/executor/spi.c
--- b/src/backend/executor/spi.c
*************** SPI_fname(TupleDesc tupdesc, int fnumber
*** 869,877 ****
  char *
  SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
  {
! 	char	   *result;
! 	Datum		origval,
! 				val;
  	bool		isnull;
  	Oid			typoid,
  				foutoid;
--- 869,875 ----
  char *
  SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber)
  {
! 	Datum		val;
  	bool		isnull;
  	Oid			typoid,
  				foutoid;
*************** SPI_getvalue(HeapTuple tuple, TupleDesc 
*** 886,892 ****
  		return NULL;
  	}
  
! 	origval = heap_getattr(tuple, fnumber, tupdesc, &isnull);
  	if (isnull)
  		return NULL;
  
--- 884,890 ----
  		return NULL;
  	}
  
! 	val = heap_getattr(tuple, fnumber, tupdesc, &isnull);
  	if (isnull)
  		return NULL;
  
*************** SPI_getvalue(HeapTuple tuple, TupleDesc 
*** 897,918 ****
  
  	getTypeOutputInfo(typoid, &foutoid, &typisvarlena);
  
! 	/*
! 	 * If we have a toasted datum, forcibly detoast it here to avoid memory
! 	 * leakage inside the type's output routine.
! 	 */
! 	if (typisvarlena)
! 		val = PointerGetDatum(PG_DETOAST_DATUM(origval));
! 	else
! 		val = origval;
! 
! 	result = OidOutputFunctionCall(foutoid, val);
! 
! 	/* Clean up detoasted copy, if any */
! 	if (val != origval)
! 		pfree(DatumGetPointer(val));
! 
! 	return result;
  }
  
  Datum
--- 895,901 ----
  
  	getTypeOutputInfo(typoid, &foutoid, &typisvarlena);
  
! 	return OidOutputFunctionCall(foutoid, val);
  }
  
  Datum
diff --git a/src/backend/utils/adt/rowtypes.c b/src/backend/utils/adt/rowtypes.c
index cb04a72..33647f7 100644
*** a/src/backend/utils/adt/rowtypes.c
--- b/src/backend/utils/adt/rowtypes.c
*************** record_out(PG_FUNCTION_ARGS)
*** 398,412 ****
  			column_info->column_type = column_type;
  		}
  
! 		/*
! 		 * If we have a toasted datum, forcibly detoast it here to avoid
! 		 * memory leakage inside the type's output routine.
! 		 */
! 		if (column_info->typisvarlena)
! 			attr = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
! 		else
! 			attr = values[i];
! 
  		value = OutputFunctionCall(&column_info->proc, attr);
  
  		/* Detect whether we need double quotes for this value */
--- 398,404 ----
  			column_info->column_type = column_type;
  		}
  
! 		attr = values[i];
  		value = OutputFunctionCall(&column_info->proc, attr);
  
  		/* Detect whether we need double quotes for this value */
*************** record_out(PG_FUNCTION_ARGS)
*** 437,448 ****
  		}
  		if (nq)
  			appendStringInfoCharMacro(&buf, '"');
- 
- 		pfree(value);
- 
- 		/* Clean up detoasted copy, if any */
- 		if (DatumGetPointer(attr) != DatumGetPointer(values[i]))
- 			pfree(DatumGetPointer(attr));
  	}
  
  	appendStringInfoChar(&buf, ')');
--- 429,434 ----
*************** record_send(PG_FUNCTION_ARGS)
*** 759,785 ****
  			column_info->column_type = column_type;
  		}
  
! 		/*
! 		 * If we have a toasted datum, forcibly detoast it here to avoid
! 		 * memory leakage inside the type's output routine.
! 		 */
! 		if (column_info->typisvarlena)
! 			attr = PointerGetDatum(PG_DETOAST_DATUM(values[i]));
! 		else
! 			attr = values[i];
! 
  		outputbytes = SendFunctionCall(&column_info->proc, attr);
- 
- 		/* We assume the result will not have been toasted */
  		pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
  		pq_sendbytes(&buf, VARDATA(outputbytes),
  					 VARSIZE(outputbytes) - VARHDRSZ);
- 
- 		pfree(outputbytes);
- 
- 		/* Clean up detoasted copy, if any */
- 		if (DatumGetPointer(attr) != DatumGetPointer(values[i]))
- 			pfree(DatumGetPointer(attr));
  	}
  
  	pfree(values);
--- 745,755 ----
  			column_info->column_type = column_type;
  		}
  
! 		attr = values[i];
  		outputbytes = SendFunctionCall(&column_info->proc, attr);
  		pq_sendint(&buf, VARSIZE(outputbytes) - VARHDRSZ, 4);
  		pq_sendbytes(&buf, VARDATA(outputbytes),
  					 VARSIZE(outputbytes) - VARHDRSZ);
  	}
  
  	pfree(values);