Clean up handling of tuple descriptors so that result-tuple descriptors

allocated by plan nodes are not leaked at end of query.  This doesn't
really matter for normal queries, but it sure does for queries invoked
repetitively inside SQL functions.  Clean up some other grotty code
associated with tupdescs, and fix a few other memory leaks exposed by
tests with simple SQL functions.

Author: tglsfdc

src/backend/access/gist/gist.c

@@ -6,7 +6,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.68 2001/01/12 00:12:58 scrappy Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.69 2001/01/29 00:39:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -154,7 +154,7 @@ gistbuild(PG_FUNCTION_ARGS)
 	{
 		tupleTable = ExecCreateTupleTable(1);
 		slot = ExecAllocTableSlot(tupleTable);
-		ExecSetSlotDescriptor(slot, htupdesc);
+		ExecSetSlotDescriptor(slot, htupdesc, false);
 	}
 	else
 	{

src/backend/access/hash/hash.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.47 2001/01/24 19:42:47 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.48 2001/01/29 00:39:13 tgl Exp $
  *
  * NOTES
  *	  This file contains only the public interface routines.
@@ -92,7 +92,7 @@ hashbuild(PG_FUNCTION_ARGS)
 	{
 		tupleTable = ExecCreateTupleTable(1);
 		slot = ExecAllocTableSlot(tupleTable);
-		ExecSetSlotDescriptor(slot, htupdesc);
+		ExecSetSlotDescriptor(slot, htupdesc, false);
 	}
 	else
 	{

src/backend/access/nbtree/nbtree.c

@@ -12,7 +12,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.76 2001/01/26 01:24:31 vadim Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.77 2001/01/29 00:39:14 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -128,7 +128,7 @@ btbuild(PG_FUNCTION_ARGS)
 	{
 		tupleTable = ExecCreateTupleTable(1);
 		slot = ExecAllocTableSlot(tupleTable);
-		ExecSetSlotDescriptor(slot, htupdesc);
+		ExecSetSlotDescriptor(slot, htupdesc, false);
 
 		/*
 		 * we never want to use sort/build if we are extending an existing

src/backend/access/rtree/rtree.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.58 2001/01/24 19:42:50 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.59 2001/01/29 00:39:15 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -125,7 +125,7 @@ rtbuild(PG_FUNCTION_ARGS)
 	{
 		tupleTable = ExecCreateTupleTable(1);
 		slot = ExecAllocTableSlot(tupleTable);
-		ExecSetSlotDescriptor(slot, htupdesc);
+		ExecSetSlotDescriptor(slot, htupdesc, false);
 	}
 	else
 	{

src/backend/catalog/index.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.139 2001/01/24 19:42:51 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.140 2001/01/29 00:39:16 tgl Exp $
  *
  *
  * INTERFACE ROUTINES
@@ -1817,7 +1817,7 @@ DefaultBuild(Relation heapRelation,
 	{
 		tupleTable = ExecCreateTupleTable(1);
 		slot = ExecAllocTableSlot(tupleTable);
-		ExecSetSlotDescriptor(slot, heapDescriptor);
+		ExecSetSlotDescriptor(slot, heapDescriptor, false);
 	}
 	else
 	{

src/backend/commands/command.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.119 2001/01/24 19:42:52 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.120 2001/01/29 00:39:20 tgl Exp $
  *
  * NOTES
  *	  The PerformAddAttribute() code, like most of the relation
@@ -1102,7 +1102,7 @@ AlterTableAddConstraint(char *relationName,
 					bool successful = true;
 					HeapScanDesc scan;
 					ExprContext *econtext;
-					TupleTableSlot *slot = makeNode(TupleTableSlot);
+					TupleTableSlot *slot;
 					HeapTuple tuple;
 					RangeTblEntry *rte;
 					List       *qual;
@@ -1169,28 +1169,28 @@ AlterTableAddConstraint(char *relationName,
 
 					qual = makeList1(expr);
 
+					/* Make tuple slot to hold tuples */
+					slot = MakeTupleTableSlot();
+					ExecSetSlotDescriptor(slot, RelationGetDescr(rel), false);
+					/* Make an expression context for ExecQual */
+					econtext = MakeExprContext(slot, CurrentMemoryContext);
+
 					/*
-					 * Scan through the rows now, making the necessary things
-					 * for ExecQual, and then call it to evaluate the
-					 * expression.
+					 * Scan through the rows now, checking the expression
+					 * at each row.
 					 */
 					while (HeapTupleIsValid(tuple = heap_getnext(scan, 0)))
 					{
-						slot->val = tuple;
-						slot->ttc_shouldFree = false;
-						slot->ttc_descIsNew = true;
-						slot->ttc_tupleDescriptor = rel->rd_att;
-						slot->ttc_buffer = InvalidBuffer;
-
-						econtext = MakeExprContext(slot, CurrentMemoryContext);
+						ExecStoreTuple(tuple, slot, InvalidBuffer, false);
 						if (!ExecQual(qual, econtext, true))
 						{
 							successful=false;
 							break;
 						}
-						FreeExprContext(econtext);
+						ResetExprContext(econtext);
 					}
 
+					FreeExprContext(econtext);
 					pfree(slot);
 
 					heap_endscan(scan);

src/backend/commands/copy.c

@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.132 2001/01/24 19:42:52 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.133 2001/01/29 00:39:20 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -638,7 +638,7 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp,
 	/* Set up a dummy tuple table too */
 	tupleTable = ExecCreateTupleTable(1);
 	slot = ExecAllocTableSlot(tupleTable);
-	ExecSetSlotDescriptor(slot, tupDesc);
+	ExecSetSlotDescriptor(slot, tupDesc, false);
 
 	if (!binary)
 	{

src/backend/executor/execJunk.c

@@ -8,12 +8,10 @@
  *
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/executor/execJunk.c,v 1.24 2001/01/24 19:42:53 momjian Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/executor/execJunk.c,v 1.25 2001/01/29 00:39:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
-
-
 #include "postgres.h"
 
 #include "access/heapam.h"
@@ -37,7 +35,7 @@
  * called 'resjunk'. If the value of this attribute is true then the
  * corresponding attribute is a "junk" attribute.
  *
- * When we initialize a plan  we call 'ExecInitJunkFilter' to create
+ * When we initialize a plan we call 'ExecInitJunkFilter' to create
  * and store the appropriate information in the 'es_junkFilter' attribute of
  * EState.
  *
@@ -63,6 +61,8 @@
 JunkFilter *
 ExecInitJunkFilter(List *targetList, TupleDesc tupType)
 {
+	MemoryContext oldContext;
+	MemoryContext junkContext;
 	JunkFilter *junkfilter;
 	List	   *cleanTargetList;
 	int			len,
@@ -75,9 +75,21 @@ ExecInitJunkFilter(List *targetList, TupleDesc tupType)
 	bool		resjunk;
 	AttrNumber	cleanResno;
 	AttrNumber *cleanMap;
-	Size		size;
 	Node	   *expr;
 
+	/*
+	 * Make a memory context that will hold the JunkFilter as well as all
+	 * the subsidiary structures we are about to create.  We use smaller-
+	 * than-default sizing parameters since we don't expect a very large
+	 * volume of stuff here.
+	 */
+	junkContext = AllocSetContextCreate(CurrentMemoryContext,
+										"JunkFilterContext",
+										1024,
+										1024,
+										ALLOCSET_DEFAULT_MAXSIZE);
+	oldContext = MemoryContextSwitchTo(junkContext);
+
 	/* ---------------------
 	 * First find the "clean" target list, i.e. all the entries
 	 * in the original target list which have a false 'resjunk'
@@ -166,7 +178,7 @@ ExecInitJunkFilter(List *targetList, TupleDesc tupType)
 	cleanLength = ExecTargetListLength(cleanTargetList);
 
 	/* ---------------------
-	 * Now calculate the "map" between the original tuples attributes
+	 * Now calculate the "map" between the original tuple's attributes
 	 * and the "clean" tuple's attributes.
 	 *
 	 * The "map" is an array of "cleanLength" attribute numbers, i.e.
@@ -177,8 +189,7 @@ ExecInitJunkFilter(List *targetList, TupleDesc tupType)
 	 */
 	if (cleanLength > 0)
 	{
-		size = cleanLength * sizeof(AttrNumber);
-		cleanMap = (AttrNumber *) palloc(size);
+		cleanMap = (AttrNumber *) palloc(cleanLength * sizeof(AttrNumber));
 		cleanResno = 1;
 		foreach(t, targetList)
 		{
@@ -226,7 +237,7 @@ ExecInitJunkFilter(List *targetList, TupleDesc tupType)
 		cleanMap = NULL;
 
 	/* ---------------------
-	 * Finally create and initialize the JunkFilter.
+	 * Finally create and initialize the JunkFilter struct.
 	 * ---------------------
 	 */
 	junkfilter = makeNode(JunkFilter);
@@ -238,20 +249,36 @@ ExecInitJunkFilter(List *targetList, TupleDesc tupType)
 	junkfilter->jf_cleanLength = cleanLength;
 	junkfilter->jf_cleanTupType = cleanTupType;
 	junkfilter->jf_cleanMap = cleanMap;
+	junkfilter->jf_junkContext = junkContext;
+
+	MemoryContextSwitchTo(oldContext);
 
 	return junkfilter;
+}
 
+/*-------------------------------------------------------------------------
+ * ExecFreeJunkFilter
+ *
+ * Release the data structures created by ExecInitJunkFilter.
+ *-------------------------------------------------------------------------
+ */
+void
+ExecFreeJunkFilter(JunkFilter *junkfilter)
+{
+	/*
+	 * Since the junkfilter is inside its own context, we just have to
+	 * delete the context and we're set.
+	 */
+	MemoryContextDelete(junkfilter->jf_junkContext);
 }
 
 /*-------------------------------------------------------------------------
  * ExecGetJunkAttribute
  *
  * Given a tuple (slot), the junk filter and a junk attribute's name,
- * extract & return the value of this attribute.
+ * extract & return the value and isNull flag of this attribute.
  *
  * It returns false iff no junk attribute with such name was found.
- *
- * NOTE: isNull might be NULL !
  *-------------------------------------------------------------------------
  */
 bool
@@ -304,7 +331,7 @@ ExecGetJunkAttribute(JunkFilter *junkfilter,
 	 * ---------------------
 	 */
 	tuple = slot->val;
-	tupType = (TupleDesc) junkfilter->jf_tupType;
+	tupType = junkfilter->jf_tupType;
 
 	*value = heap_getattr(tuple, resno, tupType, isNull);
 
@@ -328,7 +355,6 @@ ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
 	int			cleanLength;
 	bool		isNull;
 	int			i;
-	Size		size;
 	Datum	   *values;
 	char	   *nulls;
 	Datum		values_array[64];
@@ -340,8 +366,8 @@ ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
 	 */
 	tuple = slot->val;
 
-	tupType = (TupleDesc) junkfilter->jf_tupType;
-	cleanTupType = (TupleDesc) junkfilter->jf_cleanTupType;
+	tupType = junkfilter->jf_tupType;
+	cleanTupType = junkfilter->jf_cleanTupType;
 	cleanLength = junkfilter->jf_cleanLength;
 	cleanMap = junkfilter->jf_cleanMap;
 
@@ -363,11 +389,8 @@ ExecRemoveJunk(JunkFilter *junkfilter, TupleTableSlot *slot)
 	 */
 	if (cleanLength > 64)
 	{
-		size = cleanLength * sizeof(Datum);
-		values = (Datum *) palloc(size);
-
-		size = cleanLength * sizeof(char);
-		nulls = (char *) palloc(size);
+		values = (Datum *) palloc(cleanLength * sizeof(Datum));
+		nulls = (char *) palloc(cleanLength * sizeof(char));
 	}
 	else
 	{