nodeResult.c File Reference

#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeResult.h"
#include "miscadmin.h"
#include "utils/memutils.h"

Include dependency graph for nodeResult.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	ExecResult (PlanState *pstate)
void	ExecResultMarkPos (ResultState *node)
void	ExecResultRestrPos (ResultState *node)
ResultState *	ExecInitResult (Result *node, EState *estate, int eflags)
void	ExecEndResult (ResultState *node)
void	ExecReScanResult (ResultState *node)

Function Documentation

ExecEndResult()

void ExecEndResult

(

ResultState *

node

)

Definition at line 241 of file nodeResult.c.

{
    /*
     * Free the exprcontext
     */
    ExecFreeExprContext(&node->ps);
 
    /*
     * clean out the tuple table
     */
    ExecClearTuple(node->ps.ps_ResultTupleSlot);
 
    /*
     * shut down subplans
     */
    ExecEndNode(outerPlanState(node));
}

References ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), outerPlanState, ResultState::ps, and PlanState::ps_ResultTupleSlot.

Referenced by ExecEndNode().

ExecInitResult()

ResultState* ExecInitResult	(	Result *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 181 of file nodeResult.c.

{
    ResultState *resstate;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)) ||
           outerPlan(node) != NULL);
 
    /*
     * create state structure
     */
    resstate = makeNode(ResultState);
    resstate->ps.plan = (Plan *) node;
    resstate->ps.state = estate;
    resstate->ps.ExecProcNode = ExecResult;
 
    resstate->rs_done = false;
    resstate->rs_checkqual = (node->resconstantqual != NULL);
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &resstate->ps);
 
    /*
     * initialize child nodes
     */
    outerPlanState(resstate) = ExecInitNode(outerPlan(node), estate, eflags);
 
    /*
     * we don't use inner plan
     */
    Assert(innerPlan(node) == NULL);
 
    /*
     * Initialize result slot, type and projection.
     */
    ExecInitResultTupleSlotTL(&resstate->ps, &TTSOpsVirtual);
    ExecAssignProjectionInfo(&resstate->ps, NULL);
 
    /*
     * initialize child expressions
     */
    resstate->ps.qual =
        ExecInitQual(node->plan.qual, (PlanState *) resstate);
    resstate->resconstantqual =
        ExecInitQual((List *) node->resconstantqual, (PlanState *) resstate);
 
    return resstate;
}

References Assert(), EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecInitNode(), ExecInitQual(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, ExecResult(), innerPlan, makeNode, outerPlan, outerPlanState, PlanState::plan, Result::plan, ResultState::ps, PlanState::qual, Plan::qual, ResultState::resconstantqual, Result::resconstantqual, ResultState::rs_checkqual, ResultState::rs_done, PlanState::state, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanResult()

void ExecReScanResult

(

ResultState *

node

)

Definition at line 260 of file nodeResult.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    node->rs_done = false;
    node->rs_checkqual = (node->resconstantqual != NULL);
 
    /*
     * If chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan && outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References ExecReScan(), outerPlan, outerPlanState, ResultState::resconstantqual, ResultState::rs_checkqual, and ResultState::rs_done.

Referenced by ExecReScan().

ExecResult()

static TupleTableSlot* ExecResult ( PlanState *  pstate )

static

Definition at line 68 of file nodeResult.c.

{
    ResultState *node = castNode(ResultState, pstate);
    TupleTableSlot *outerTupleSlot;
    PlanState  *outerPlan;
    ExprContext *econtext;
 
    CHECK_FOR_INTERRUPTS();
 
    econtext = node->ps.ps_ExprContext;
 
    /*
     * check constant qualifications like (2 > 1), if not already done
     */
    if (node->rs_checkqual)
    {
        bool        qualResult = ExecQual(node->resconstantqual, econtext);
 
        node->rs_checkqual = false;
        if (!qualResult)
        {
            node->rs_done = true;
            return NULL;
        }
    }
 
    /*
     * Reset per-tuple memory context to free any expression evaluation
     * storage allocated in the previous tuple cycle.
     */
    ResetExprContext(econtext);
 
    /*
     * if rs_done is true then it means that we were asked to return a
     * constant tuple and we already did the last time ExecResult() was
     * called, OR that we failed the constant qual check. Either way, now we
     * are through.
     */
    if (!node->rs_done)
    {
        outerPlan = outerPlanState(node);
 
        if (outerPlan != NULL)
        {
            /*
             * retrieve tuples from the outer plan until there are no more.
             */
            outerTupleSlot = ExecProcNode(outerPlan);
 
            if (TupIsNull(outerTupleSlot))
                return NULL;
 
            /*
             * prepare to compute projection expressions, which will expect to
             * access the input tuples as varno OUTER.
             */
            econtext->ecxt_outertuple = outerTupleSlot;
        }
        else
        {
            /*
             * if we don't have an outer plan, then we are just generating the
             * results from a constant target list.  Do it only once.
             */
            node->rs_done = true;
        }
 
        /* form the result tuple using ExecProject(), and return it */
        return ExecProject(node->ps.ps_ProjInfo);
    }
 
    return NULL;
}

References castNode, CHECK_FOR_INTERRUPTS, ExprContext::ecxt_outertuple, ExecProcNode(), ExecProject(), ExecQual(), outerPlan, outerPlanState, ResultState::ps, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, ResultState::resconstantqual, ResetExprContext, ResultState::rs_checkqual, ResultState::rs_done, and TupIsNull.

Referenced by ExecInitResult().

ExecResultMarkPos()

void ExecResultMarkPos

(

ResultState *

node

)

Definition at line 147 of file nodeResult.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    if (outerPlan != NULL)
        ExecMarkPos(outerPlan);
    else
        elog(DEBUG2, "Result nodes do not support mark/restore");
}

References DEBUG2, elog(), ExecMarkPos(), outerPlan, and outerPlanState.

Referenced by ExecMarkPos().

ExecResultRestrPos()

void ExecResultRestrPos

(

ResultState *

node

)

Definition at line 162 of file nodeResult.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    if (outerPlan != NULL)
        ExecRestrPos(outerPlan);
    else
        elog(ERROR, "Result nodes do not support mark/restore");
}

References elog(), ERROR, ExecRestrPos(), outerPlan, and outerPlanState.

Referenced by ExecRestrPos().