Split some storage out to separate subcontexts of fcontext.

Put the JunkFilter and its result slot (and thence also
some subsidiary data such as the result tupledesc) into a
separate subcontext "jfcontext".  This doesn't accomplish
a lot at this point, because we make a new JunkFilter each
time through the SQL function.  However, the plan is to make
the fcontext long-lived, and that raises the possibility
that we'll need a new JunkFilter because the plan for the
result-generating query changes.  A separate context makes
it easy to free the obsoleted data when that happens.

Also, instead of always running the sub-executor in fcontext,
make a separate context for it if we're doing lazy eval of
a SRF, and otherwise just run it inside CurrentMemoryContext.

diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c
index b264060d33dde773e58d618680b432b8f183304b..12121ad74e763042cbbd133454961a0d9ac0bbac 100644 (file)
--- a/src/backend/executor/functions.c
+++ b/src/backend/executor/functions.c
@@ -107,6 +107,8 @@ typedef struct execution_state
  * which we free at completion.  In non-returnsSet mode, this is just a child
  * of the call-time context.  In returnsSet mode, it is made a child of the
  * FmgrInfo's fn_mcxt so that it will survive between fmgr_sql calls.
+ * The fcontext may have subsidiary contexts jfcontext and/or subcontext,
+ * which have somewhat shorter lifespans.
  *
  * 3. SQLFunctionLink is a tiny struct that just holds pointers to
  * the SQLFunctionHashEntry and the current SQLFunctionCache (if any).
@@ -151,6 +153,7 @@ typedef struct SQLFunctionCache
    bool        lazyEvalOK;     /* true if lazyEval is safe */
    bool        shutdown_reg;   /* true if registered shutdown callback */
    bool        lazyEval;       /* true if using lazyEval for result query */
+   bool        ownSubcontext;  /* is subcontext really a separate context? */
 
    ParamListInfo paramLI;      /* Param list representing current args */
 
@@ -178,6 +181,9 @@ typedef struct SQLFunctionCache
 
    MemoryContext fcontext;     /* memory context holding this struct and all
                                 * subsidiary data */
+   MemoryContext jfcontext;    /* subsidiary memory context holding
+                                * junkFilter, result slot, and related data */
+   MemoryContext subcontext;   /* subsidiary memory context for sub-executor */
 } SQLFunctionCache;
 
 typedef SQLFunctionCache *SQLFunctionCachePtr;
@@ -617,8 +623,8 @@ init_sql_fcache(FunctionCallInfo fcinfo, bool lazyEvalOK)
     */
    pcontext = func->returnsSet ? finfo->fn_mcxt : CurrentMemoryContext;
    fcontext = AllocSetContextCreate(pcontext,
-                                    "SQL function execution",
-                                    ALLOCSET_DEFAULT_SIZES);
+                                    "SQL function cache",
+                                    ALLOCSET_SMALL_SIZES);
 
    oldcontext = MemoryContextSwitchTo(fcontext);
 
@@ -791,6 +797,9 @@ init_execution_state(SQLFunctionCachePtr fcache)
     * nothing to coerce to.  (XXX Frequently, the JunkFilter isn't doing
     * anything very interesting, but much of this module expects it to be
     * there anyway.)
+    *
+    * The JunkFilter, its result slot, and its tupledesc are kept in a
+    * subsidiary memory context so that we can free them easily when needed.
     */
    if (fcache->func->rettype != VOIDOID)
    {
@@ -798,8 +807,14 @@ init_execution_state(SQLFunctionCachePtr fcache)
        List       *resulttlist;
        MemoryContext oldcontext;
 
-       /* The result slot and JunkFilter must be in the fcontext */
-       oldcontext = MemoryContextSwitchTo(fcache->fcontext);
+       /* Create or reset the jfcontext */
+       if (fcache->jfcontext == NULL)
+           fcache->jfcontext = AllocSetContextCreate(fcache->fcontext,
+                                                     "SQL function junkfilter",
+                                                     ALLOCSET_SMALL_SIZES);
+       else
+           MemoryContextReset(fcache->jfcontext);
+       oldcontext = MemoryContextSwitchTo(fcache->jfcontext);
 
        slot = MakeSingleTupleTableSlot(NULL, &TTSOpsMinimalTuple);
 
@@ -1265,14 +1280,46 @@ postquel_start(execution_state *es, SQLFunctionCachePtr fcache)
    Assert(ActiveSnapshotSet());
 
    /*
-    * Run the sub-executor in a child of fcontext.  The sub-executor is
-    * responsible for deleting per-tuple information.  (XXX in the case of a
-    * long-lived FmgrInfo, this policy potentially causes memory leakage, but
-    * it's not very clear where we could keep stuff instead.  Fortunately,
-    * there are few if any cases where set-returning functions are invoked
-    * via FmgrInfos that would outlive the calling query.)
+    * In lazyEval mode for a SRF, we must run the sub-executor in a child of
+    * fcontext, so that it can survive across multiple calls to fmgr_sql.
+    * (XXX in the case of a long-lived FmgrInfo, this policy potentially
+    * causes memory leakage, but it's not very clear where we could keep
+    * stuff instead.  Fortunately, there are few if any cases where
+    * set-returning functions are invoked via FmgrInfos that would outlive
+    * the calling query.)  Otherwise, we're going to run it to completion
+    * before exiting fmgr_sql, so it can perfectly well run in the caller's
+    * context.
     */
-   oldcontext = MemoryContextSwitchTo(fcache->fcontext);
+   if (es->lazyEval && fcache->func->returnsSet)
+   {
+       fcache->subcontext = AllocSetContextCreate(fcache->fcontext,
+                                                  "SQL function execution",
+                                                  ALLOCSET_DEFAULT_SIZES);
+       fcache->ownSubcontext = true;
+   }
+   else if (es->stmt->commandType == CMD_UTILITY)
+   {
+       /*
+        * The code path using a sub-executor is pretty good about cleaning up
+        * cruft, since the executor will make its own sub-context.  We don't
+        * really need an additional layer of sub-context in that case.
+        * However, if this is a utility statement, it won't make its own
+        * sub-context, so it seems advisable to make one that we can free on
+        * completion.
+        */
+       fcache->subcontext = AllocSetContextCreate(CurrentMemoryContext,
+                                                  "SQL function execution",
+                                                  ALLOCSET_DEFAULT_SIZES);
+       fcache->ownSubcontext = true;
+   }
+   else
+   {
+       fcache->subcontext = CurrentMemoryContext;
+       fcache->ownSubcontext = false;
+   }
+
+   /* Switch into the selected subcontext (might be a no-op) */
+   oldcontext = MemoryContextSwitchTo(fcache->subcontext);
 
    /*
     * If this query produces the function result, send its output to the
@@ -1335,8 +1382,8 @@ postquel_getnext(execution_state *es, SQLFunctionCachePtr fcache)
    bool        result;
    MemoryContext oldcontext;
 
-   /* Run the sub-executor in a child of fcontext */
-   oldcontext = MemoryContextSwitchTo(fcache->fcontext);
+   /* Run the sub-executor in subcontext */
+   oldcontext = MemoryContextSwitchTo(fcache->subcontext);
 
    if (es->qd->operation == CMD_UTILITY)
    {
@@ -1375,8 +1422,8 @@ postquel_end(execution_state *es, SQLFunctionCachePtr fcache)
 {
    MemoryContext oldcontext;
 
-   /* Run the sub-executor in a child of fcontext */
-   oldcontext = MemoryContextSwitchTo(fcache->fcontext);
+   /* Run the sub-executor in subcontext */
+   oldcontext = MemoryContextSwitchTo(fcache->subcontext);
 
    /* mark status done to ensure we don't do ExecutorEnd twice */
    es->status = F_EXEC_DONE;
@@ -1394,6 +1441,11 @@ postquel_end(execution_state *es, SQLFunctionCachePtr fcache)
    es->qd = NULL;
 
    MemoryContextSwitchTo(oldcontext);
+
+   /* Delete the subcontext, if it's actually a separate context */
+   if (fcache->ownSubcontext)
+       MemoryContextDelete(fcache->subcontext);
+   fcache->subcontext = NULL;
 }
 
 /*