nodeWorktablescan.c File Reference

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

Include dependency graph for nodeWorktablescan.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	WorkTableScanNext (WorkTableScanState *node)
static bool	WorkTableScanRecheck (WorkTableScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecWorkTableScan (PlanState *pstate)
WorkTableScanState *	ExecInitWorkTableScan (WorkTableScan *node, EState *estate, int eflags)
void	ExecReScanWorkTableScan (WorkTableScanState *node)

Function Documentation

ExecInitWorkTableScan()

WorkTableScanState * ExecInitWorkTableScan	(	WorkTableScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 130 of file nodeWorktablescan.c.

{
    WorkTableScanState *scanstate;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * WorkTableScan should not have any children.
     */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);
 
    /*
     * create new WorkTableScanState for node
     */
    scanstate = makeNode(WorkTableScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
    scanstate->ss.ps.ExecProcNode = ExecWorkTableScan;
    scanstate->rustate = NULL;  /* we'll set this later */
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &scanstate->ss.ps);
 
    /*
     * tuple table initialization
     */
    ExecInitResultTypeTL(&scanstate->ss.ps);
 
    /* signal that return type is not yet known */
    scanstate->ss.ps.resultopsset = true;
    scanstate->ss.ps.resultopsfixed = false;
 
    ExecInitScanTupleSlot(estate, &scanstate->ss, NULL, &TTSOpsMinimalTuple);
 
    /*
     * initialize child expressions
     */
    scanstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
 
    /*
     * Do not yet initialize projection info, see ExecWorkTableScan() for
     * details.
     */
 
    return scanstate;
}

References Assert, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), PlanState::ExecProcNode, ExecWorkTableScan(), innerPlan, makeNode, outerPlan, PlanState::plan, ScanState::ps, PlanState::qual, PlanState::resultopsfixed, PlanState::resultopsset, WorkTableScanState::rustate, WorkTableScan::scan, WorkTableScanState::ss, PlanState::state, and TTSOpsMinimalTuple.

Referenced by ExecInitNode().

ExecReScanWorkTableScan()

void ExecReScanWorkTableScan

(

WorkTableScanState *

node

)

Definition at line 191 of file nodeWorktablescan.c.

{
    if (node->ss.ps.ps_ResultTupleSlot)
        ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    ExecScanReScan(&node->ss);
 
    /* No need (or way) to rescan if ExecWorkTableScan not called yet */
    if (node->rustate)
        tuplestore_rescan(node->rustate->working_table);
}

References ExecClearTuple(), ExecScanReScan(), ScanState::ps, PlanState::ps_ResultTupleSlot, WorkTableScanState::rustate, WorkTableScanState::ss, tuplestore_rescan(), and RecursiveUnionState::working_table.

Referenced by ExecReScan().

ExecWorkTableScan()

static TupleTableSlot * ExecWorkTableScan ( PlanState *  pstate )

static

Definition at line 81 of file nodeWorktablescan.c.

{
    WorkTableScanState *node = castNode(WorkTableScanState, pstate);
 
    /*
     * On the first call, find the ancestor RecursiveUnion's state via the
     * Param slot reserved for it.  (We can't do this during node init because
     * there are corner cases where we'll get the init call before the
     * RecursiveUnion does.)
     */
    if (node->rustate == NULL)
    {
        WorkTableScan *plan = (WorkTableScan *) node->ss.ps.plan;
        EState     *estate = node->ss.ps.state;
        ParamExecData *param;
 
        param = &(estate->es_param_exec_vals[plan->wtParam]);
        Assert(param->execPlan == NULL);
        Assert(!param->isnull);
        node->rustate = castNode(RecursiveUnionState, DatumGetPointer(param->value));
        Assert(node->rustate);
 
        /*
         * The scan tuple type (ie, the rowtype we expect to find in the work
         * table) is the same as the result rowtype of the ancestor
         * RecursiveUnion node.  Note this depends on the assumption that
         * RecursiveUnion doesn't allow projection.
         */
        ExecAssignScanType(&node->ss,
                           ExecGetResultType(&node->rustate->ps));
 
        /*
         * Now we can initialize the projection info.  This must be completed
         * before we can call ExecScan().
         */
        ExecAssignScanProjectionInfo(&node->ss);
    }
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) WorkTableScanNext,
                    (ExecScanRecheckMtd) WorkTableScanRecheck);
}

References Assert, castNode, DatumGetPointer(), ExecAssignScanProjectionInfo(), ExecAssignScanType(), ExecGetResultType(), ExecScan(), PlanState::plan, plan, RecursiveUnionState::ps, ScanState::ps, WorkTableScanState::rustate, WorkTableScanState::ss, PlanState::state, WorkTableScanNext(), and WorkTableScanRecheck().

Referenced by ExecInitWorkTableScan().

WorkTableScanNext()

static TupleTableSlot * WorkTableScanNext ( WorkTableScanState *  node )

static

Definition at line 30 of file nodeWorktablescan.c.

{
    TupleTableSlot *slot;
    Tuplestorestate *tuplestorestate;
 
    /*
     * get information from the estate and scan state
     *
     * Note: we intentionally do not support backward scan.  Although it would
     * take only a couple more lines here, it would force nodeRecursiveunion.c
     * to create the tuplestore with backward scan enabled, which has a
     * performance cost.  In practice backward scan is never useful for a
     * worktable plan node, since it cannot appear high enough in the plan
     * tree of a scrollable cursor to be exposed to a backward-scan
     * requirement.  So it's not worth expending effort to support it.
     *
     * Note: we are also assuming that this node is the only reader of the
     * worktable.  Therefore, we don't need a private read pointer for the
     * tuplestore, nor do we need to tell tuplestore_gettupleslot to copy.
     */
    Assert(ScanDirectionIsForward(node->ss.ps.state->es_direction));
 
    tuplestorestate = node->rustate->working_table;
 
    /*
     * Get the next tuple from tuplestore. Return NULL if no more tuples.
     */
    slot = node->ss.ss_ScanTupleSlot;
    (void) tuplestore_gettupleslot(tuplestorestate, true, false, slot);
    return slot;
}

References Assert, EState::es_direction, ScanState::ps, WorkTableScanState::rustate, ScanDirectionIsForward, WorkTableScanState::ss, ScanState::ss_ScanTupleSlot, PlanState::state, tuplestore_gettupleslot(), and RecursiveUnionState::working_table.

Referenced by ExecWorkTableScan().

WorkTableScanRecheck()

static bool WorkTableScanRecheck ( WorkTableScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 66 of file nodeWorktablescan.c.

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

Referenced by ExecWorkTableScan().