nodeSubqueryscan.c File Reference

#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeSubqueryscan.h"

Include dependency graph for nodeSubqueryscan.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	SubqueryNext (SubqueryScanState *node)
static bool	SubqueryRecheck (SubqueryScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecSubqueryScan (PlanState *pstate)
SubqueryScanState *	ExecInitSubqueryScan (SubqueryScan *node, EState *estate, int eflags)
void	ExecEndSubqueryScan (SubqueryScanState *node)
void	ExecReScanSubqueryScan (SubqueryScanState *node)

Function Documentation

ExecEndSubqueryScan()

void ExecEndSubqueryScan

(

SubqueryScanState *

node

)

Definition at line 168 of file nodeSubqueryscan.c.

{
    /*
     * close down subquery
     */
    ExecEndNode(node->subplan);
}

References ExecEndNode(), and SubqueryScanState::subplan.

Referenced by ExecEndNode().

ExecInitSubqueryScan()

SubqueryScanState* ExecInitSubqueryScan	(	SubqueryScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 97 of file nodeSubqueryscan.c.

{
    SubqueryScanState *subquerystate;
 
    /* check for unsupported flags */
    Assert(!(eflags & EXEC_FLAG_MARK));
 
    /* SubqueryScan should not have any "normal" children */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);
 
    /*
     * create state structure
     */
    subquerystate = makeNode(SubqueryScanState);
    subquerystate->ss.ps.plan = (Plan *) node;
    subquerystate->ss.ps.state = estate;
    subquerystate->ss.ps.ExecProcNode = ExecSubqueryScan;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &subquerystate->ss.ps);
 
    /*
     * initialize subquery
     */
    subquerystate->subplan = ExecInitNode(node->subplan, estate, eflags);
 
    /*
     * Initialize scan slot and type (needed by ExecAssignScanProjectionInfo)
     */
    ExecInitScanTupleSlot(estate, &subquerystate->ss,
                          ExecGetResultType(subquerystate->subplan),
                          ExecGetResultSlotOps(subquerystate->subplan, NULL));
 
    /*
     * The slot used as the scantuple isn't the slot above (outside of EPQ),
     * but the one from the node below.
     */
    subquerystate->ss.ps.scanopsset = true;
    subquerystate->ss.ps.scanops = ExecGetResultSlotOps(subquerystate->subplan,
                                                        &subquerystate->ss.ps.scanopsfixed);
    subquerystate->ss.ps.resultopsset = true;
    subquerystate->ss.ps.resultops = subquerystate->ss.ps.scanops;
    subquerystate->ss.ps.resultopsfixed = subquerystate->ss.ps.scanopsfixed;
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&subquerystate->ss.ps);
    ExecAssignScanProjectionInfo(&subquerystate->ss);
 
    /*
     * initialize child expressions
     */
    subquerystate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) subquerystate);
 
    return subquerystate;
}

References Assert, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecGetResultSlotOps(), ExecGetResultType(), ExecInitNode(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), PlanState::ExecProcNode, ExecSubqueryScan(), innerPlan, makeNode, outerPlan, PlanState::plan, ScanState::ps, PlanState::qual, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, SubqueryScan::scan, PlanState::scanops, PlanState::scanopsfixed, PlanState::scanopsset, SubqueryScanState::ss, PlanState::state, SubqueryScanState::subplan, and SubqueryScan::subplan.

Referenced by ExecInitNode().

ExecReScanSubqueryScan()

void ExecReScanSubqueryScan

(

SubqueryScanState *

node

)

Definition at line 183 of file nodeSubqueryscan.c.

{
    ExecScanReScan(&node->ss);
 
    /*
     * ExecReScan doesn't know about my subplan, so I have to do
     * changed-parameter signaling myself.  This is just as well, because the
     * subplan has its own memory context in which its chgParam state lives.
     */
    if (node->ss.ps.chgParam != NULL)
        UpdateChangedParamSet(node->subplan, node->ss.ps.chgParam);
 
    /*
     * if chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (node->subplan->chgParam == NULL)
        ExecReScan(node->subplan);
}

References PlanState::chgParam, ExecReScan(), ExecScanReScan(), ScanState::ps, SubqueryScanState::ss, SubqueryScanState::subplan, and UpdateChangedParamSet().

Referenced by ExecReScan().

ExecSubqueryScan()

static TupleTableSlot* ExecSubqueryScan ( PlanState *  pstate )

static

Definition at line 83 of file nodeSubqueryscan.c.

{
    SubqueryScanState *node = castNode(SubqueryScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) SubqueryNext,
                    (ExecScanRecheckMtd) SubqueryRecheck);
}

References castNode, ExecScan(), SubqueryScanState::ss, SubqueryNext(), and SubqueryRecheck().

Referenced by ExecInitSubqueryScan().

SubqueryNext()

static TupleTableSlot * SubqueryNext ( SubqueryScanState *  node )

static

Definition at line 46 of file nodeSubqueryscan.c.

{
    TupleTableSlot *slot;
 
    /*
     * Get the next tuple from the sub-query.
     */
    slot = ExecProcNode(node->subplan);
 
    /*
     * We just return the subplan's result slot, rather than expending extra
     * cycles for ExecCopySlot().  (Our own ScanTupleSlot is used only for
     * EvalPlanQual rechecks.)
     */
    return slot;
}

References ExecProcNode(), and SubqueryScanState::subplan.

Referenced by ExecSubqueryScan().

SubqueryRecheck()

static bool SubqueryRecheck ( SubqueryScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 67 of file nodeSubqueryscan.c.

{
    /* nothing to check */
    return true;
}

Referenced by ExecSubqueryScan().