Header And Logo

PostgreSQL
| The world's most advanced open source database.

Functions

nodeResult.h File Reference

#include "nodes/execnodes.h"
Include dependency graph for nodeResult.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

ResultStateExecInitResult (Result *node, EState *estate, int eflags)
TupleTableSlotExecResult (ResultState *node)
void ExecEndResult (ResultState *node)
void ExecResultMarkPos (ResultState *node)
void ExecResultRestrPos (ResultState *node)
void ExecReScanResult (ResultState *node)

Function Documentation

void ExecEndResult ( ResultState node  ) 

Definition at line 276 of file nodeResult.c.

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

Referenced by ExecEndNode().

{
    /*
     * Free the exprcontext
     */
    ExecFreeExprContext(&node->ps);

    /*
     * clean out the tuple table
     */
    ExecClearTuple(node->ps.ps_ResultTupleSlot);

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

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

Definition at line 206 of file nodeResult.c.

References Assert, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecAssignResultTypeFromTL(), ExecInitExpr(), ExecInitNode(), ExecInitResultTupleSlot(), innerPlan, makeNode, NULL, outerPlan, outerPlanState, Result::plan, PlanState::plan, ResultState::ps, PlanState::ps_TupFromTlist, Plan::qual, PlanState::qual, ResultState::resconstantqual, Result::resconstantqual, ResultState::rs_checkqual, ResultState::rs_done, PlanState::state, Plan::targetlist, and PlanState::targetlist.

Referenced by ExecInitNode().

{
    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->rs_done = false;
    resstate->rs_checkqual = (node->resconstantqual == NULL) ? false : true;

    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &resstate->ps);

    resstate->ps.ps_TupFromTlist = false;

    /*
     * tuple table initialization
     */
    ExecInitResultTupleSlot(estate, &resstate->ps);

    /*
     * initialize child expressions
     */
    resstate->ps.targetlist = (List *)
        ExecInitExpr((Expr *) node->plan.targetlist,
                     (PlanState *) resstate);
    resstate->ps.qual = (List *)
        ExecInitExpr((Expr *) node->plan.qual,
                     (PlanState *) resstate);
    resstate->resconstantqual = ExecInitExpr((Expr *) node->resconstantqual,
                                             (PlanState *) resstate);

    /*
     * initialize child nodes
     */
    outerPlanState(resstate) = ExecInitNode(outerPlan(node), estate, eflags);

    /*
     * we don't use inner plan
     */
    Assert(innerPlan(node) == NULL);

    /*
     * initialize tuple type and projection info
     */
    ExecAssignResultTypeFromTL(&resstate->ps);
    ExecAssignProjectionInfo(&resstate->ps, NULL);

    return resstate;
}

void ExecReScanResult ( ResultState node  ) 

Definition at line 295 of file nodeResult.c.

References PlanState::chgParam, ExecReScan(), PlanState::lefttree, NULL, ResultState::ps, PlanState::ps_TupFromTlist, ResultState::resconstantqual, ResultState::rs_checkqual, and ResultState::rs_done.

Referenced by ExecReScan().

{
    node->rs_done = false;
    node->ps.ps_TupFromTlist = false;
    node->rs_checkqual = (node->resconstantqual == NULL) ? false : true;

    /*
     * If chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (node->ps.lefttree &&
        node->ps.lefttree->chgParam == NULL)
        ExecReScan(node->ps.lefttree);
}

TupleTableSlot* ExecResult ( ResultState node  ) 

Definition at line 67 of file nodeResult.c.

References ExprContext::ecxt_outertuple, ExecProcNode(), ExecProject(), ExecQual(), ExprEndResult, ExprMultipleResult, NULL, outerPlanState, ResultState::ps, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::ps_TupFromTlist, ResultState::resconstantqual, ResetExprContext, ResultState::rs_checkqual, ResultState::rs_done, and TupIsNull.

Referenced by ExecProcNode().

{
    TupleTableSlot *outerTupleSlot;
    TupleTableSlot *resultSlot;
    PlanState  *outerPlan;
    ExprContext *econtext;
    ExprDoneCond isDone;

    econtext = node->ps.ps_ExprContext;

    /*
     * check constant qualifications like (2 > 1), if not already done
     */
    if (node->rs_checkqual)
    {
        bool        qualResult = ExecQual((List *) node->resconstantqual,
                                          econtext,
                                          false);

        node->rs_checkqual = false;
        if (!qualResult)
        {
            node->rs_done = true;
            return NULL;
        }
    }

    /*
     * Check to see if we're still projecting out tuples from a previous scan
     * tuple (because there is a function-returning-set in the projection
     * expressions).  If so, try to project another one.
     */
    if (node->ps.ps_TupFromTlist)
    {
        resultSlot = ExecProject(node->ps.ps_ProjInfo, &isDone);
        if (isDone == ExprMultipleResult)
            return resultSlot;
        /* Done with that source tuple... */
        node->ps.ps_TupFromTlist = false;
    }

    /*
     * Reset per-tuple memory context to free any expression evaluation
     * storage allocated in the previous tuple cycle.  Note this can't happen
     * until we're done projecting out tuples from a scan tuple.
     */
    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.
     */
    while (!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 --- unless
         * the projection produces an empty set, in which case we must loop
         * back to see if there are more outerPlan tuples.
         */
        resultSlot = ExecProject(node->ps.ps_ProjInfo, &isDone);

        if (isDone != ExprEndResult)
        {
            node->ps.ps_TupFromTlist = (isDone == ExprMultipleResult);
            return resultSlot;
        }
    }

    return NULL;
}

void ExecResultMarkPos ( ResultState node  ) 

Definition at line 172 of file nodeResult.c.

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

Referenced by ExecMarkPos().

{
    PlanState  *outerPlan = outerPlanState(node);

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

void ExecResultRestrPos ( ResultState node  ) 

Definition at line 187 of file nodeResult.c.

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

Referenced by ExecRestrPos().

{
    PlanState  *outerPlan = outerPlanState(node);

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