nodeCtescan.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeCtescan.h:

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

Go to the source code of this file.

Functions
CteScanState *	ExecInitCteScan (CteScan *node, EState *estate, int eflags)
void	ExecEndCteScan (CteScanState *node)
void	ExecReScanCteScan (CteScanState *node)

Function Documentation

ExecEndCteScan()

void ExecEndCteScan ( CteScanState *  node )

extern

Definition at line 289 of file nodeCtescan.c.

{
    /*
     * If I am the leader, free the tuplestore.
     */
    if (node->leader == node)
    {
        tuplestore_end(node->cte_table);
        node->cte_table = NULL;
    }
}

References CteScanState::cte_table, fb(), CteScanState::leader, and tuplestore_end().

Referenced by ExecEndNode().

ExecInitCteScan()

CteScanState * ExecInitCteScan ( CteScan *  node, EState *  estate, int  eflags  )

extern

Definition at line 176 of file nodeCtescan.c.

{
    CteScanState *scanstate;
    ParamExecData *prmdata;
 
    /* check for unsupported flags */
    Assert(!(eflags & EXEC_FLAG_MARK));
 
    /*
     * For the moment we have to force the tuplestore to allow REWIND, because
     * we might be asked to rescan the CTE even though upper levels didn't
     * tell us to be prepared to do it efficiently.  Annoying, since this
     * prevents truncation of the tuplestore.  XXX FIXME
     *
     * Note: if we are in an EPQ recheck plan tree, it's likely that no access
     * to the tuplestore is needed at all, making this even more annoying.
     * It's not worth improving that as long as all the read pointers would
     * have REWIND anyway, but if we ever improve this logic then that aspect
     * should be considered too.
     */
    eflags |= EXEC_FLAG_REWIND;
 
    /*
     * CteScan should not have any children.
     */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);
 
    /*
     * create new CteScanState for node
     */
    scanstate = makeNode(CteScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
    scanstate->ss.ps.ExecProcNode = ExecCteScan;
    scanstate->eflags = eflags;
    scanstate->cte_table = NULL;
    scanstate->eof_cte = false;
 
    /*
     * Find the already-initialized plan for the CTE query.
     */
    scanstate->cteplanstate = (PlanState *) list_nth(estate->es_subplanstates,
                                                     node->ctePlanId - 1);
 
    /*
     * The Param slot associated with the CTE query is used to hold a pointer
     * to the CteState of the first CteScan node that initializes for this
     * CTE.  This node will be the one that holds the shared state for all the
     * CTEs, particularly the shared tuplestore.
     */
    prmdata = &(estate->es_param_exec_vals[node->cteParam]);
    Assert(prmdata->execPlan == NULL);
    Assert(!prmdata->isnull);
    scanstate->leader = castNode(CteScanState, DatumGetPointer(prmdata->value));
    if (scanstate->leader == NULL)
    {
        /* I am the leader */
        prmdata->value = PointerGetDatum(scanstate);
        scanstate->leader = scanstate;
        scanstate->cte_table = tuplestore_begin_heap(true, false, work_mem);
        tuplestore_set_eflags(scanstate->cte_table, scanstate->eflags);
        scanstate->readptr = 0;
    }
    else
    {
        /* Not the leader */
        /* Create my own read pointer, and ensure it is at start */
        scanstate->readptr =
            tuplestore_alloc_read_pointer(scanstate->leader->cte_table,
                                          scanstate->eflags);
        tuplestore_select_read_pointer(scanstate->leader->cte_table,
                                       scanstate->readptr);
        tuplestore_rescan(scanstate->leader->cte_table);
    }
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &scanstate->ss.ps);
 
    /*
     * The scan tuple type (ie, the rowtype we expect to find in the work
     * table) is the same as the result rowtype of the CTE query.
     */
    ExecInitScanTupleSlot(estate, &scanstate->ss,
                          ExecGetResultType(scanstate->cteplanstate),
                          &TTSOpsMinimalTuple, 0);
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&scanstate->ss.ps);
    ExecAssignScanProjectionInfo(&scanstate->ss);
 
    /*
     * initialize child expressions
     */
    scanstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
 
    return scanstate;
}

References Assert, castNode, CteScan::cteParam, CteScan::ctePlanId, DatumGetPointer(), EState::es_param_exec_vals, EState::es_subplanstates, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecCteScan(), ExecGetResultType(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), fb(), innerPlan, list_nth(), makeNode, outerPlan, PointerGetDatum(), CteScan::scan, TTSOpsMinimalTuple, tuplestore_alloc_read_pointer(), tuplestore_begin_heap(), tuplestore_rescan(), tuplestore_select_read_pointer(), tuplestore_set_eflags(), and work_mem.

Referenced by ExecInitNode().

ExecReScanCteScan()

void ExecReScanCteScan ( CteScanState *  node )

extern

Definition at line 308 of file nodeCtescan.c.

{
    Tuplestorestate *tuplestorestate = node->leader->cte_table;
 
    if (node->ss.ps.ps_ResultTupleSlot)
        ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    ExecScanReScan(&node->ss);
 
    /*
     * Clear the tuplestore if a new scan of the underlying CTE is required.
     * This implicitly resets all the tuplestore's read pointers.  Note that
     * multiple CTE nodes might redundantly clear the tuplestore; that's OK,
     * and not unduly expensive.  We'll stop taking this path as soon as
     * somebody has attempted to read something from the underlying CTE
     * (thereby causing its chgParam to be cleared).
     */
    if (node->leader->cteplanstate->chgParam != NULL)
    {
        tuplestore_clear(tuplestorestate);
        node->leader->eof_cte = false;
    }
    else
    {
        /*
         * Else, just rewind my own pointer.  Either the underlying CTE
         * doesn't need a rescan (and we can re-read what's in the tuplestore
         * now), or somebody else already took care of it.
         */
        tuplestore_select_read_pointer(tuplestorestate, node->readptr);
        tuplestore_rescan(tuplestorestate);
    }
}

References PlanState::chgParam, CteScanState::cte_table, CteScanState::cteplanstate, CteScanState::eof_cte, ExecClearTuple(), ExecScanReScan(), fb(), CteScanState::leader, ScanState::ps, PlanState::ps_ResultTupleSlot, CteScanState::readptr, CteScanState::ss, tuplestore_clear(), tuplestore_rescan(), and tuplestore_select_read_pointer().

Referenced by ExecReScan().