nodeNestloop.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeNestloop.h:

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

Go to the source code of this file.

Functions
NestLoopState *	ExecInitNestLoop (NestLoop *node, EState *estate, int eflags)
void	ExecEndNestLoop (NestLoopState *node)
void	ExecReScanNestLoop (NestLoopState *node)

Function Documentation

ExecEndNestLoop()

void ExecEndNestLoop

(

NestLoopState *

node

)

Definition at line 362 of file nodeNestloop.c.

{
    NL1_printf("ExecEndNestLoop: %s\n",
               "ending node processing");
 
    /*
     * close down subplans
     */
    ExecEndNode(outerPlanState(node));
    ExecEndNode(innerPlanState(node));
 
    NL1_printf("ExecEndNestLoop: %s\n",
               "node processing ended");
}

References ExecEndNode(), innerPlanState, NL1_printf, and outerPlanState.

Referenced by ExecEndNode().

ExecInitNestLoop()

NestLoopState* ExecInitNestLoop	(	NestLoop *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 263 of file nodeNestloop.c.

{
    NestLoopState *nlstate;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    NL1_printf("ExecInitNestLoop: %s\n",
               "initializing node");
 
    /*
     * create state structure
     */
    nlstate = makeNode(NestLoopState);
    nlstate->js.ps.plan = (Plan *) node;
    nlstate->js.ps.state = estate;
    nlstate->js.ps.ExecProcNode = ExecNestLoop;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &nlstate->js.ps);
 
    /*
     * initialize child nodes
     *
     * If we have no parameters to pass into the inner rel from the outer,
     * tell the inner child that cheap rescans would be good.  If we do have
     * such parameters, then there is no point in REWIND support at all in the
     * inner child, because it will always be rescanned with fresh parameter
     * values.
     */
    outerPlanState(nlstate) = ExecInitNode(outerPlan(node), estate, eflags);
    if (node->nestParams == NIL)
        eflags |= EXEC_FLAG_REWIND;
    else
        eflags &= ~EXEC_FLAG_REWIND;
    innerPlanState(nlstate) = ExecInitNode(innerPlan(node), estate, eflags);
 
    /*
     * Initialize result slot, type and projection.
     */
    ExecInitResultTupleSlotTL(&nlstate->js.ps, &TTSOpsVirtual);
    ExecAssignProjectionInfo(&nlstate->js.ps, NULL);
 
    /*
     * initialize child expressions
     */
    nlstate->js.ps.qual =
        ExecInitQual(node->join.plan.qual, (PlanState *) nlstate);
    nlstate->js.jointype = node->join.jointype;
    nlstate->js.joinqual =
        ExecInitQual(node->join.joinqual, (PlanState *) nlstate);
 
    /*
     * detect whether we need only consider the first matching inner tuple
     */
    nlstate->js.single_match = (node->join.inner_unique ||
                                node->join.jointype == JOIN_SEMI);
 
    /* set up null tuples for outer joins, if needed */
    switch (node->join.jointype)
    {
        case JOIN_INNER:
        case JOIN_SEMI:
            break;
        case JOIN_LEFT:
        case JOIN_ANTI:
            nlstate->nl_NullInnerTupleSlot =
                ExecInitNullTupleSlot(estate,
                                      ExecGetResultType(innerPlanState(nlstate)),
                                      &TTSOpsVirtual);
            break;
        default:
            elog(ERROR, "unrecognized join type: %d",
                 (int) node->join.jointype);
    }
 
    /*
     * finally, wipe the current outer tuple clean.
     */
    nlstate->nl_NeedNewOuter = true;
    nlstate->nl_MatchedOuter = false;
 
    NL1_printf("ExecInitNestLoop: %s\n",
               "node initialized");
 
    return nlstate;
}

References Assert(), elog(), ERROR, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecGetResultType(), ExecInitNode(), ExecInitNullTupleSlot(), ExecInitQual(), ExecInitResultTupleSlotTL(), ExecNestLoop(), PlanState::ExecProcNode, Join::inner_unique, innerPlan, innerPlanState, NestLoop::join, JOIN_ANTI, JOIN_INNER, JOIN_LEFT, JOIN_SEMI, JoinState::joinqual, Join::joinqual, JoinState::jointype, Join::jointype, NestLoopState::js, makeNode, NestLoop::nestParams, NIL, NL1_printf, NestLoopState::nl_MatchedOuter, NestLoopState::nl_NeedNewOuter, NestLoopState::nl_NullInnerTupleSlot, outerPlan, outerPlanState, PlanState::plan, JoinState::ps, PlanState::qual, JoinState::single_match, PlanState::state, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecReScanNestLoop()

void ExecReScanNestLoop

(

NestLoopState *

node

)

Definition at line 382 of file nodeNestloop.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    /*
     * If outerPlan->chgParam is not null then plan will be automatically
     * re-scanned by first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
 
    /*
     * innerPlan is re-scanned for each new outer tuple and MUST NOT be
     * re-scanned from here or you'll get troubles from inner index scans when
     * outer Vars are used as run-time keys...
     */
 
    node->nl_NeedNewOuter = true;
    node->nl_MatchedOuter = false;
}

References ExecReScan(), NestLoopState::nl_MatchedOuter, NestLoopState::nl_NeedNewOuter, outerPlan, and outerPlanState.

Referenced by ExecReScan().