Avoid leaking memory while evaluating arguments for a table function.

ExecMakeTableFunctionResult evaluated the arguments for a function-in-FROM
in the query-lifespan memory context.  This is insignificant in simple
cases where the function relation is scanned only once; but if the function
is in a sub-SELECT or is on the inside of a nested loop, any memory
consumed during argument evaluation can add up quickly.  (The potential for
trouble here had been foreseen long ago, per existing comments; but we'd
not previously seen a complaint from the field about it.)  To fix, create
an additional temporary context just for this purpose.

Per an example from MauMau.  Back-patch to all active branches.

diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c
index 40a62a187784ec36a5a6c36ec988414b2ee6ccc5..81b404b5265f212596d235dae2516b1dd0027ae9 100644 (file)
--- a/src/backend/executor/execQual.c
+++ b/src/backend/executor/execQual.c
@@ -1985,6 +1985,7 @@ ExecMakeFunctionResultNoSets(FuncExprState *fcache,
 Tuplestorestate *
 ExecMakeTableFunctionResult(ExprState *funcexpr,
                                                        ExprContext *econtext,
+                                                       MemoryContext argContext,
                                                        TupleDesc expectedDesc,
                                                        bool randomAccess)
 {
@@ -2063,13 +2064,19 @@ ExecMakeTableFunctionResult(ExprState *funcexpr,
                /*
                 * Evaluate the function's argument list.
                 *
-                * Note: ideally, we'd do this in the per-tuple context, but then the
-                * argument values would disappear when we reset the context in the
-                * inner loop.  So do it in caller context.  Perhaps we should make a
-                * separate context just to hold the evaluated arguments?
+                * We can't do this in the per-tuple context: the argument values
+                * would disappear when we reset that context in the inner loop.  And
+                * the caller's CurrentMemoryContext is typically a query-lifespan
+                * context, so we don't want to leak memory there.  We require the
+                * caller to pass a separate memory context that can be used for this,
+                * and can be reset each time through to avoid bloat.
                 */
+               MemoryContextReset(argContext);
+               oldcontext = MemoryContextSwitchTo(argContext);
                fcinfo.flinfo = &(fcache->func);
                argDone = ExecEvalFuncArgs(&fcinfo, fcache->args, econtext);
+               MemoryContextSwitchTo(oldcontext);
+
                /* We don't allow sets in the arguments of the table function */
                if (argDone != ExprSingleResult)
                        ereport(ERROR,

diff --git a/src/backend/executor/nodeFunctionscan.c b/src/backend/executor/nodeFunctionscan.c
index 0e18207915ffc2a297abc48d661b2614b55b7223..521088553c1bf710ab7147a9db7b29e70a878343 100644 (file)
--- a/src/backend/executor/nodeFunctionscan.c
+++ b/src/backend/executor/nodeFunctionscan.c
@@ -25,6 +25,7 @@
 #include "executor/nodeFunctionscan.h"
 #include "funcapi.h"
 #include "utils/builtins.h"
+#include "utils/memutils.h"
 
 
 static TupleTableSlot *FunctionNext(FunctionScanState *node);
@@ -64,6 +65,7 @@ FunctionNext(FunctionScanState *node)
                node->tuplestorestate = tuplestorestate =
                        ExecMakeTableFunctionResult(node->funcexpr,
                                                                                node->ss.ps.ps_ExprContext,
+                                                                               node->argcontext,
                                                                                node->tupdesc,
                                                                                node->eflags & EXEC_FLAG_BACKWARD);
        }
@@ -223,6 +225,19 @@ ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags)
        ExecAssignResultTypeFromTL(&scanstate->ss.ps);
        ExecAssignScanProjectionInfo(&scanstate->ss);
 
+       /*
+        * Create a memory context that ExecMakeTableFunctionResult can use to
+        * evaluate function arguments in.  We can't use the per-tuple context for
+        * this because it gets reset too often; but we don't want to leak
+        * evaluation results into the query-lifespan context either.  We just
+        * need one context, because we evaluate each function separately.
+        */
+       scanstate->argcontext = AllocSetContextCreate(CurrentMemoryContext,
+                                                                                                 "Table function arguments",
+                                                                                                 ALLOCSET_DEFAULT_MINSIZE,
+                                                                                                 ALLOCSET_DEFAULT_INITSIZE,
+                                                                                                 ALLOCSET_DEFAULT_MAXSIZE);
+
        return scanstate;
 }
 

diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h
index ec52d64c689de9faf5965384bd95422e7f6a0b14..f3342c3802220a2eb963afd076826e3b4c72bb01 100644 (file)
--- a/src/include/executor/executor.h
+++ b/src/include/executor/executor.h
@@ -207,6 +207,7 @@ extern Datum GetAttributeByName(HeapTupleHeader tuple, const char *attname,
                                   bool *isNull);
 extern Tuplestorestate *ExecMakeTableFunctionResult(ExprState *funcexpr,
                                                        ExprContext *econtext,
+                                                       MemoryContext argContext,
                                                        TupleDesc expectedDesc,
                                                        bool randomAccess);
 extern Datum ExecEvalExprSwitchContext(ExprState *expression, ExprContext *econtext,

diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index 5d301e44fa7d727d6a3d5a1a422816a385cff2b6..1bdec152e8967fbc93ef70f65fde6d8d8bd59679 100644 (file)
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -1315,6 +1315,7 @@ typedef struct SubqueryScanState
  *             tupdesc                         expected return tuple description
  *             tuplestorestate         private state of tuplestore.c
  *             funcexpr                        state for function expression being evaluated
+ *             argcontext                      memory context to evaluate function arguments in
  * ----------------
  */
 typedef struct FunctionScanState
@@ -1324,6 +1325,7 @@ typedef struct FunctionScanState
        TupleDesc       tupdesc;
        Tuplestorestate *tuplestorestate;
        ExprState  *funcexpr;
+       MemoryContext argcontext;
 } FunctionScanState;
 
 /* ----------------