nodeProjectSet.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeProjectSet.h:

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

Go to the source code of this file.

Functions
ProjectSetState *	ExecInitProjectSet (ProjectSet *node, EState *estate, int eflags)
void	ExecEndProjectSet (ProjectSetState *node)
void	ExecReScanProjectSet (ProjectSetState *node)

Function Documentation

ExecEndProjectSet()

void ExecEndProjectSet

(

ProjectSetState *

node

)

Definition at line 328 of file nodeProjectSet.c.

{
    /*
     * shut down subplans
     */
    ExecEndNode(outerPlanState(node));
}

References ExecEndNode(), and outerPlanState.

Referenced by ExecEndNode().

ExecInitProjectSet()

ProjectSetState * ExecInitProjectSet	(	ProjectSet *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 227 of file nodeProjectSet.c.

{
    ProjectSetState *state;
    ListCell   *lc;
    int         off;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)));
 
    /*
     * create state structure
     */
    state = makeNode(ProjectSetState);
    state->ps.plan = (Plan *) node;
    state->ps.state = estate;
    state->ps.ExecProcNode = ExecProjectSet;
 
    state->pending_srf_tuples = false;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &state->ps);
 
    /*
     * initialize child nodes
     */
    outerPlanState(state) = ExecInitNode(outerPlan(node), estate, eflags);
 
    /*
     * we don't use inner plan
     */
    Assert(innerPlan(node) == NULL);
 
    /*
     * tuple table and result type initialization
     */
    ExecInitResultTupleSlotTL(&state->ps, &TTSOpsVirtual);
 
    /* Create workspace for per-tlist-entry expr state & SRF-is-done state */
    state->nelems = list_length(node->plan.targetlist);
    state->elems = (Node **)
        palloc(sizeof(Node *) * state->nelems);
    state->elemdone = (ExprDoneCond *)
        palloc(sizeof(ExprDoneCond) * state->nelems);
 
    /*
     * Build expressions to evaluate targetlist.  We can't use
     * ExecBuildProjectionInfo here, since that doesn't deal with SRFs.
     * Instead compile each expression separately, using
     * ExecInitFunctionResultSet where applicable.
     */
    off = 0;
    foreach(lc, node->plan.targetlist)
    {
        TargetEntry *te = (TargetEntry *) lfirst(lc);
        Expr       *expr = te->expr;
 
        if ((IsA(expr, FuncExpr) && ((FuncExpr *) expr)->funcretset) ||
            (IsA(expr, OpExpr) && ((OpExpr *) expr)->opretset))
        {
            state->elems[off] = (Node *)
                ExecInitFunctionResultSet(expr, state->ps.ps_ExprContext,
                                          &state->ps);
        }
        else
        {
            Assert(!expression_returns_set((Node *) expr));
            state->elems[off] = (Node *) ExecInitExpr(expr, &state->ps);
        }
 
        off++;
    }
 
    /* We don't support any qual on ProjectSet nodes */
    Assert(node->plan.qual == NIL);
 
    /*
     * Create a memory context that ExecMakeFunctionResultSet 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 use one
     * context for the arguments of all tSRFs, as they have roughly equivalent
     * lifetimes.
     */
    state->argcontext = AllocSetContextCreate(CurrentMemoryContext,
                                              "tSRF function arguments",
                                              ALLOCSET_DEFAULT_SIZES);
 
    return state;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CurrentMemoryContext, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecInitExpr(), ExecInitFunctionResultSet(), ExecInitNode(), ExecInitResultTupleSlotTL(), ExecProjectSet(), TargetEntry::expr, expression_returns_set(), innerPlan, IsA, lfirst, list_length(), makeNode, NIL, outerPlan, outerPlanState, palloc(), ProjectSet::plan, Plan::qual, Plan::targetlist, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanProjectSet()

void ExecReScanProjectSet

(

ProjectSetState *

node

)

Definition at line 337 of file nodeProjectSet.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    /* Forget any incompletely-evaluated SRFs */
    node->pending_srf_tuples = false;
 
    /*
     * If chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References ExecReScan(), outerPlan, outerPlanState, and ProjectSetState::pending_srf_tuples.

Referenced by ExecReScan().