#include "nodes/execnodes.h"

Include dependency graph for nodeFunctionscan.h:

This graph shows which files directly or indirectly include this file:

Functions
FunctionScanState *	ExecInitFunctionScan (FunctionScan node, EState estate, int eflags)

void	ExecEndFunctionScan (FunctionScanState *node)

void	ExecReScanFunctionScan (FunctionScanState *node)

Function Documentation

◆ ExecEndFunctionScan()

void ExecEndFunctionScan ( FunctionScanState * node )

Definition at line 530 of file nodeFunctionscan.c.

 {
     int         i;
  
     /*
      * Release slots and tuplestore resources
      */
     for (i = 0; i < node->nfuncs; i++)
     {
         FunctionScanPerFuncState *fs = &node->funcstates[i];
  
         if (fs->tstore != NULL)
         {
             tuplestore_end(node->funcstates[i].tstore);
             fs->tstore = NULL;
         }
     }
 }

References FunctionScanState::funcstates, i, FunctionScanState::nfuncs, FunctionScanPerFuncState::tstore, and tuplestore_end().

Referenced by ExecEndNode().

◆ ExecInitFunctionScan()

FunctionScanState* ExecInitFunctionScan	(	FunctionScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 279 of file nodeFunctionscan.c.

 {
     FunctionScanState *scanstate;
     int         nfuncs = list_length(node->functions);
     TupleDesc   scan_tupdesc;
     int         i,
                 natts;
     ListCell   *lc;
  
     /* check for unsupported flags */
     Assert(!(eflags & EXEC_FLAG_MARK));
  
     /*
      * FunctionScan should not have any children.
      */
     Assert(outerPlan(node) == NULL);
     Assert(innerPlan(node) == NULL);
  
     /*
      * create new ScanState for node
      */
     scanstate = makeNode(FunctionScanState);
     scanstate->ss.ps.plan = (Plan *) node;
     scanstate->ss.ps.state = estate;
     scanstate->ss.ps.ExecProcNode = ExecFunctionScan;
     scanstate->eflags = eflags;
  
     /*
      * are we adding an ordinality column?
      */
     scanstate->ordinality = node->funcordinality;
  
     scanstate->nfuncs = nfuncs;
     if (nfuncs == 1 && !node->funcordinality)
         scanstate->simple = true;
     else
         scanstate->simple = false;
  
     /*
      * Ordinal 0 represents the "before the first row" position.
      *
      * We need to track ordinal position even when not adding an ordinality
      * column to the result, in order to handle backwards scanning properly
      * with multiple functions with different result sizes. (We can't position
      * any individual function's tuplestore any more than 1 place beyond its
      * end, so when scanning backwards, we need to know when to start
      * including the function in the scan again.)
      */
     scanstate->ordinal = 0;
  
     /*
      * Miscellaneous initialization
      *
      * create expression context for node
      */
     ExecAssignExprContext(estate, &scanstate->ss.ps);
  
     scanstate->funcstates = palloc(nfuncs * sizeof(FunctionScanPerFuncState));
  
     natts = 0;
     i = 0;
     foreach(lc, node->functions)
     {
         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
         Node       *funcexpr = rtfunc->funcexpr;
         int         colcount = rtfunc->funccolcount;
         FunctionScanPerFuncState *fs = &scanstate->funcstates[i];
         TupleDesc   tupdesc;
  
         fs->setexpr =
             ExecInitTableFunctionResult((Expr *) funcexpr,
                                         scanstate->ss.ps.ps_ExprContext,
                                         &scanstate->ss.ps);
  
         /*
          * Don't allocate the tuplestores; the actual calls to the functions
          * do that.  NULL means that we have not called the function yet (or
          * need to call it again after a rescan).
          */
         fs->tstore = NULL;
         fs->rowcount = -1;
  
         /*
          * Now build a tupdesc showing the result type we expect from the
          * function.  If we have a coldeflist then that takes priority (note
          * the parser enforces that there is one if the function's nominal
          * output type is RECORD).  Otherwise use get_expr_result_type.
          *
          * Note that if the function returns a named composite type, that may
          * now contain more or different columns than it did when the plan was
          * made.  For both that and the RECORD case, we need to check tuple
          * compatibility.  ExecMakeTableFunctionResult handles some of this,
          * and CheckVarSlotCompatibility provides a backstop.
          */
         if (rtfunc->funccolnames != NIL)
         {
             tupdesc = BuildDescFromLists(rtfunc->funccolnames,
                                          rtfunc->funccoltypes,
                                          rtfunc->funccoltypmods,
                                          rtfunc->funccolcollations);
  
             /*
              * For RECORD results, make sure a typmod has been assigned.  (The
              * function should do this for itself, but let's cover things in
              * case it doesn't.)
              */
             BlessTupleDesc(tupdesc);
         }
         else
         {
             TypeFuncClass functypclass;
             Oid         funcrettype;
  
             functypclass = get_expr_result_type(funcexpr,
                                                 &funcrettype,
                                                 &tupdesc);
  
             if (functypclass == TYPEFUNC_COMPOSITE ||
                 functypclass == TYPEFUNC_COMPOSITE_DOMAIN)
             {
                 /* Composite data type, e.g. a table's row type */
                 Assert(tupdesc);
                 /* Must copy it out of typcache for safety */
                 tupdesc = CreateTupleDescCopy(tupdesc);
             }
             else if (functypclass == TYPEFUNC_SCALAR)
             {
                 /* Base data type, i.e. scalar */
                 tupdesc = CreateTemplateTupleDesc(1);
                 TupleDescInitEntry(tupdesc,
                                    (AttrNumber) 1,
                                    NULL,    /* don't care about the name here */
                                    funcrettype,
                                    -1,
                                    0);
                 TupleDescInitEntryCollation(tupdesc,
                                             (AttrNumber) 1,
                                             exprCollation(funcexpr));
             }
             else
             {
                 /* crummy error message, but parser should have caught this */
                 elog(ERROR, "function in FROM has unsupported return type");
             }
         }
  
         fs->tupdesc = tupdesc;
         fs->colcount = colcount;
  
         /*
          * We only need separate slots for the function results if we are
          * doing ordinality or multiple functions; otherwise, we'll fetch
          * function results directly into the scan slot.
          */
         if (!scanstate->simple)
         {
             fs->func_slot = ExecInitExtraTupleSlot(estate, fs->tupdesc,
                                                    &TTSOpsMinimalTuple);
         }
         else
             fs->func_slot = NULL;
  
         natts += colcount;
         i++;
     }
  
     /*
      * Create the combined TupleDesc
      *
      * If there is just one function without ordinality, the scan result
      * tupdesc is the same as the function result tupdesc --- except that we
      * may stuff new names into it below, so drop any rowtype label.
      */
     if (scanstate->simple)
     {
         scan_tupdesc = CreateTupleDescCopy(scanstate->funcstates[0].tupdesc);
         scan_tupdesc->tdtypeid = RECORDOID;
         scan_tupdesc->tdtypmod = -1;
     }
     else
     {
         AttrNumber  attno = 0;
  
         if (node->funcordinality)
             natts++;
  
         scan_tupdesc = CreateTemplateTupleDesc(natts);
  
         for (i = 0; i < nfuncs; i++)
         {
             TupleDesc   tupdesc = scanstate->funcstates[i].tupdesc;
             int         colcount = scanstate->funcstates[i].colcount;
             int         j;
  
             for (j = 1; j <= colcount; j++)
                 TupleDescCopyEntry(scan_tupdesc, ++attno, tupdesc, j);
         }
  
         /* If doing ordinality, add a column of type "bigint" at the end */
         if (node->funcordinality)
         {
             TupleDescInitEntry(scan_tupdesc,
                                ++attno,
                                NULL,    /* don't care about the name here */
                                INT8OID,
                                -1,
                                0);
         }
  
         Assert(attno == natts);
     }
  
     /*
      * Initialize scan slot and type.
      */
     ExecInitScanTupleSlot(estate, &scanstate->ss, scan_tupdesc,
                           &TTSOpsMinimalTuple);
  
     /*
      * Initialize result slot, type and projection.
      */
     ExecInitResultTypeTL(&scanstate->ss.ps);
     ExecAssignScanProjectionInfo(&scanstate->ss);
  
     /*
      * initialize child expressions
      */
     scanstate->ss.ps.qual =
         ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
  
     /*
      * 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_SIZES);
  
     return scanstate;
 }

Referenced by ExecInitNode().

◆ ExecReScanFunctionScan()

void ExecReScanFunctionScan ( FunctionScanState * node )

Definition at line 556 of file nodeFunctionscan.c.

 {
     FunctionScan *scan = (FunctionScan *) node->ss.ps.plan;
     int         i;
     Bitmapset  *chgparam = node->ss.ps.chgParam;
  
     if (node->ss.ps.ps_ResultTupleSlot)
         ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
     for (i = 0; i < node->nfuncs; i++)
     {
         FunctionScanPerFuncState *fs = &node->funcstates[i];
  
         if (fs->func_slot)
             ExecClearTuple(fs->func_slot);
     }
  
     ExecScanReScan(&node->ss);
  
     /*
      * Here we have a choice whether to drop the tuplestores (and recompute
      * the function outputs) or just rescan them.  We must recompute if an
      * expression contains changed parameters, else we rescan.
      *
      * XXX maybe we should recompute if the function is volatile?  But in
      * general the executor doesn't conditionalize its actions on that.
      */
     if (chgparam)
     {
         ListCell   *lc;
  
         i = 0;
         foreach(lc, scan->functions)
         {
             RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
  
             if (bms_overlap(chgparam, rtfunc->funcparams))
             {
                 if (node->funcstates[i].tstore != NULL)
                 {
                     tuplestore_end(node->funcstates[i].tstore);
                     node->funcstates[i].tstore = NULL;
                 }
                 node->funcstates[i].rowcount = -1;
             }
             i++;
         }
     }
  
     /* Reset ordinality counter */
     node->ordinal = 0;
  
     /* Make sure we rewind any remaining tuplestores */
     for (i = 0; i < node->nfuncs; i++)
     {
         if (node->funcstates[i].tstore != NULL)
             tuplestore_rescan(node->funcstates[i].tstore);
     }
 }

References bms_overlap(), PlanState::chgParam, ExecClearTuple(), ExecScanReScan(), FunctionScanPerFuncState::func_slot, FunctionScanState::funcstates, FunctionScan::functions, i, if(), lfirst, FunctionScanState::nfuncs, FunctionScanState::ordinal, PlanState::plan, ScanState::ps, PlanState::ps_ResultTupleSlot, FunctionScanPerFuncState::rowcount, FunctionScanState::ss, FunctionScanPerFuncState::tstore, tuplestore_end(), and tuplestore_rescan().

Referenced by ExecReScan().